Updating samples for CUDA 12.5

Fix cudaExtent.width set error.

.gitignore

@@ -0,0 +1 @@
+.vscode/*

CHANGELOG.md

@@ -0,0 +1,143 @@
+## Changelog
+
+### CUDA 12.5
+
+### CUDA 12.4
+* Added graphConditionalNodes Sample
+
+### CUDA 12.3
+* Added cuDLA samples
+* Fixed jitLto regression
+
+### CUDA 12.2
+* libNVVM samples received updates
+* Fixed jitLto Case issues
+* Enabled HOST_COMPILER flag to the makefiles for GCC which is untested but may still work.
+
+### CUDA 12.1
+* Added new sample for Large Kernels
+
+### CUDA 12.0
+* Added new flags for JIT compiling 
+* Removed deprecated APIs in Hopper Architecture
+
+### CUDA 11.6
+* Added new folder structure for samples
+* Added support of Visual Studio 2022 to all samples supported on [Windows](#windows-1).
+* All CUDA samples are now only available on [GitHub](https://github.com/nvidia/cuda-samples). They are no longer available via CUDA toolkit.
+
+### CUDA 11.5
+* Added `cuDLAHybridMode`. Demonstrate usage of cuDLA in hybrid mode.
+* Added `cuDLAStandaloneMode`. Demonstrate usage of cuDLA in standalone mode.
+* Added `cuDLAErrorReporting`. Demonstrate DLA error detection via CUDA.
+* Added `graphMemoryNodes`. Demonstrates memory allocations and frees within CUDA graphs using Graph APIs and Stream Capture APIs.
+* Added `graphMemoryFootprint`. Demonstrates how graph memory nodes re-use virtual addresses and physical memory.
+* All samples from CUDA toolkit are now available on [GitHub](https://github.com/nvidia/cuda-samples).
+
+### CUDA 11.4 update 1
+* Added support for VS Code on linux platform.
+
+### CUDA 11.4
+* Added `cdpQuadtree`. Demonstrates Quad Trees implementation using CUDA Dynamic Parallelism.
+* Updated `simpleVulkan`, `simpleVulkanMMAP` and `vulkanImageCUDA`. Demonstrates use of SPIR-V shaders.
+
+### CUDA 11.3
+*  Added `streamOrderedAllocationIPC`. Demonstrates Inter Process Communication using one process per GPU for computation.
+*  Added `simpleCUBLAS_LU`. Demonstrates batched matrix LU decomposition using cuBLAS API `cublas<t>getrfBatched()`
+*  Updated `simpleVulkan`. Demonstrates use of timeline semaphore.
+*  Updated multiple samples to use pinned memory using `cudaMallocHost()`.
+
+### CUDA 11.2
+*  Added `streamOrderedAllocation`. Demonstrates stream ordered memory allocation on a GPU using cudaMallocAsync and cudaMemPool family of APIs.
+*  Added `streamOrderedAllocationP2P`. Demonstrates peer-to-peer access of stream ordered memory allocated using cudaMallocAsync and cudaMemPool family of APIs.
+*  Dropped Visual Studio 2015 support from all the windows supported samples.
+*  FreeImage is no longer distributed with the CUDA Samples. On Windows, see the [Dependencies](./README.md#freeimage) section for more details on how to set up FreeImage. On Linux, it is recommended to install FreeImage with your distribution's package manager.
+*  All the samples using CUDA Pipeline & Arrive-wait barriers are been updated to use new `cuda::pipeline` and `cuda::barrier` interfaces.
+*  Updated all the samples to build with parallel build option `--threads` of `nvcc` cuda compiler.
+*  Added `cudaNvSciNvMedia`. Demonstrates CUDA-NvMedia interop via NvSciBuf/NvSciSync APIs.
+*  Added `simpleGL`. Demonstrates interoperability between CUDA and OpenGL.
+
+### CUDA 11.1
+*  Added `watershedSegmentationNPP`. Demonstrates how to use the NPP watershed segmentation function.
+*  Added `batchedLabelMarkersAndLabelCompressionNPP`. Demonstrates how to use the NPP label markers generation and label compression functions based on a Union Find (UF) algorithm including both single image and batched image versions.
+*  Dropped Visual Studio 2012, 2013 support from all the windows supported samples.
+*  Added kernel performing warp aggregated atomic max in multi buckets using cg::labeled_partition & cg::reduce in `warpAggregatedAtomicsCG`.
+*  Added extended CG shuffle mechanics to `shfl_scan` sample.
+*  Added `cudaOpenMP`. Demonstrates how to use OpenMP API to write an application for multiple GPUs.
+*  Added `simpleZeroCopy`. Demonstrates how to use zero copy, kernels can read and write directly to pinned system memory.
+
+### CUDA 11.0
+*  Added `dmmaTensorCoreGemm`. Demonstrates double precision GEMM computation using the Double precision Warp Matrix Multiply and Accumulate (WMMA) API introduced with CUDA 11 in Ampere chip family tensor cores.
+*  Added `bf16TensorCoreGemm`. Demonstrates __nv_bfloat16 (e8m7) GEMM computation using the __nv_bfloat16 WMMA API introduced with CUDA 11 in Ampere chip family tensor cores.
+*  Added `tf32TensorCoreGemm`. Demonstrates tf32 (e8m10) GEMM computation using the tf32 WMMA API introduced with CUDA 11 in Ampere chip family tensor cores.
+*  Added `globalToShmemAsyncCopy`. Demonstrates async copy of data from global to shared memory when on compute capability 8.0 or higher. Also demonstrates arrive-wait barrier for synchronization.
+*  Added `simpleAWBarrier`. Demonstrates arrive wait barriers.
+*  Added `simpleAttributes`. Demonstrates the stream attributes that affect L2 locality.
+*  Added warp aggregated atomic multi bucket increments kernel using labeled_partition cooperative groups in `warpAggregatedAtomicsCG` which can be used on compute capability 7.0 and above GPU architectures.
+*  Added `binaryPartitionCG`. Demonstrates  binary partition cooperative groups and reduction within the thread block.
+*  Added two new reduction kernels in `reduction` one which demonstrates reduce_add_sync intrinstic supported on compute capability 8.0 and another which uses cooperative_groups::reduce function which does thread_block_tile level reduction introduced from CUDA 11.0.
+*  Added `cudaCompressibleMemory`. Demonstrates compressible memory allocation using cuMemMap API.
+*  Added `simpleVulkanMMAP`. Demonstrates Vulkan CUDA Interop via cuMemMap APIs.
+*  Added `concurrentKernels`. Demonstrates the use of CUDA streams for concurrent execution of several kernels on a GPU.
+*  Dropped Mac OSX support from all samples.
+
+### CUDA 10.2
+*  Added `simpleD3D11`. Demonstrates CUDA-D3D11 External Resource Interoperability APIs for updating D3D11 buffers from CUDA and synchronization between D3D11 and CUDA with Keyed Mutexes.
+*  Added `simpleDrvRuntime`. Demonstrates CUDA Driver and Runtime APIs working together to load fatbinary of a CUDA kernel.
+*  Added `vectorAddMMAP`. Demonstrates how cuMemMap API allows the user to specify the physical properties of their memory while retaining the contiguous nature of their access.
+*  Added `memMapIPCDrv`. Demonstrates Inter Process Communication using cuMemMap APIs.
+*  Added `cudaNvSci`. Demonstrates CUDA-NvSciBuf/NvSciSync Interop.
+*  Added `jacobiCudaGraphs`. Demonstrates Instantiated CUDA Graph Update with Jacobi Iterative Method using different approaches.
+*  Added `cuSolverSp_LinearSolver`. Demonstrates cuSolverSP's LU, QR and Cholesky factorization.
+*  Added `MersenneTwisterGP11213`. Demonstrates the Mersenne Twister random number generator GP11213 in cuRAND.
+
+### CUDA 10.1 Update 2
+*  Added `vulkanImageCUDA`. Demonstrates how to perform Vulkan image - CUDA Interop.
+*  Added `nvJPEG_encoder`. Demonstrates encoding of jpeg images using NVJPEG Library.
+*  Added Windows OS support to `nvJPEG` sample.
+*  Added `boxFilterNPP`. Demonstrates how to use NPP FilterBox function to perform a box filter.
+*  Added `cannyEdgeDetectorNPP`. Demonstrates the nppiFilterCannyBorder_8u_C1R Canny Edge Detection image filter function.
+
+### CUDA 10.1 Update 1
+*  Added `NV12toBGRandResize`. Demonstrates how to convert and resize NV12 frames to BGR planars frames using CUDA in batch.
+*  Added `EGLStream_CUDA_Interop`. Demonstrates data exchange between CUDA and EGL Streams.
+*  Added `cuSolverDn_LinearSolver`. Demonstrates cuSolverDN's LU, QR and Cholesky factorization.
+*  Added support of Visual Studio 2019 to all samples supported on [Windows](./README.md#windows-1).
+
+### CUDA 10.1
+*  Added `immaTensorCoreGemm`. Demonstrates integer GEMM computation using the Warp Matrix Multiply and Accumulate (WMMA) API for integers employing the Tensor Cores.
+*  Added `simpleIPC`. Demonstrates Inter Process Communication with one process per GPU for computation.
+*  Added `nvJPEG`. Demonstrates single and batched decoding of jpeg images using NVJPEG Library.
+*  Added `bandwidthTest`. It measures the memcopy bandwidth of the GPU and memcpy bandwidth across PCI-e.
+*  Added `reduction`. Demonstrates several important optimization strategies for Data-Parallel Algorithms like reduction.
+*  Update all the samples to support CUDA 10.1.
+
+
+### CUDA 10.0
+*  Added `simpleCudaGraphs`. Demonstrates CUDA Graphs creation, instantiation and launch using Graphs APIs and Stream Capture APIs.
+*  Added `conjugateGradientCudaGraphs`. Demonstrates conjugate gradient solver on GPU using CUBLAS and CUSPARSE library calls captured and called using CUDA Graph APIs.
+*  Added `simpleVulkan`. Demonstrates Vulkan - CUDA Interop.
+*  Added `simpleD3D12`. Demonstrates DX12 - CUDA Interop.
+*  Added `UnifiedMemoryPerf`. Demonstrates performance comparision of various memory types involved in system.
+*  Added `p2pBandwidthLatencyTest`. Demonstrates Peer-To-Peer (P2P) data transfers between pairs of GPUs and computes latency and bandwidth.
+*  Added `systemWideAtomics`. Demonstrates system wide atomic instructions.
+*  Added `simpleCUBLASXT`. Demonstrates CUBLAS-XT library which performs GEMM operations over multiple GPUs.
+*  Added Windows OS support to `conjugateGradientMultiDeviceCG` sample.
+*  Removed support of Visual Studio 2010 from all samples.
+
+
+### CUDA 9.2
+
+This is the first release of CUDA Samples on GitHub:
+*  Added `vectorAdd_nvrtc`. Demonstrates runtime compilation library using NVRTC of a simple vectorAdd kernel.
+*  Added `warpAggregatedAtomicsCG`. Demonstrates warp aggregated atomics using Cooperative Groups.
+*  Added `deviceQuery`. Enumerates the properties of the CUDA devices present in the system.
+*  Added `matrixMul`. Demonstrates a matrix multiplication using shared memory through tiled approach.
+*  Added `matrixMulDrv`. Demonstrates a matrix multiplication using shared memory through tiled approach, uses CUDA Driver API.
+*  Added `cudaTensorCoreGemm`. Demonstrates a GEMM computation using the Warp Matrix Multiply and Accumulate (WMMA) API introduced in CUDA 9, as well as the new Tensor Cores introduced in the Volta chip family.
+*  Added `simpleVoteIntrinsics` which uses *_sync equivalent of the vote intrinsics _any, _all added since CUDA 9.0.
+*  Added `shfl_scan` which uses *_sync equivalent of the shfl intrinsics added since CUDA 9.0.
+*  Added `conjugateGradientMultiBlockCG`. Demonstrates a conjugate gradient solver on GPU using Multi Block Cooperative Groups.
+*  Added `conjugateGradientMultiDeviceCG`. Demonstrates a conjugate gradient solver on multiple GPUs using Multi Device Cooperative Groups, also uses unified memory prefetching and usage hints APIs.
+*  Added `simpleCUBLAS`. Demonstrates how perform GEMM operations using CUBLAS library.
+*  Added `simpleCUFFT`. Demonstrates how perform FFT operations using CUFFT library.

Common/GL/freeglut.h

@@ -0,0 +1,22 @@
+#ifndef  __FREEGLUT_H__
+#define  __FREEGLUT_H__
+
+/*
+ * freeglut.h
+ *
+ * The freeglut library include file
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "freeglut_std.h"
+#include "freeglut_ext.h"
+
+/*** END OF FILE ***/
+
+#endif /* __FREEGLUT_H__ */

Common/GL/freeglut_ext.h

@@ -0,0 +1,115 @@
+#ifndef  __FREEGLUT_EXT_H__
+#define  __FREEGLUT_EXT_H__
+
+/*
+ * freeglut_ext.h
+ *
+ * The non-GLUT-compatible extensions to the freeglut library include file
+ *
+ * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>
+ * Creation date: Thu Dec 2 1999
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * GLUT API Extension macro definitions -- behaviour when the user clicks on an "x" to close a window
+ */
+#define GLUT_ACTION_EXIT                         0
+#define GLUT_ACTION_GLUTMAINLOOP_RETURNS         1
+#define GLUT_ACTION_CONTINUE_EXECUTION           2
+
+/*
+ * Create a new rendering context when the user opens a new window?
+ */
+#define GLUT_CREATE_NEW_CONTEXT                  0
+#define GLUT_USE_CURRENT_CONTEXT                 1
+
+/*
+ * GLUT API Extension macro definitions -- the glutGet parameters
+ */
+#define  GLUT_ACTION_ON_WINDOW_CLOSE        0x01F9
+
+#define  GLUT_WINDOW_BORDER_WIDTH           0x01FA
+#define  GLUT_WINDOW_HEADER_HEIGHT          0x01FB
+
+#define  GLUT_VERSION                       0x01FC
+
+#define  GLUT_RENDERING_CONTEXT             0x01FD
+
+/*
+ * Process loop function, see freeglut_main.c
+ */
+FGAPI void    FGAPIENTRY glutMainLoopEvent(void);
+FGAPI void    FGAPIENTRY glutLeaveMainLoop(void);
+
+/*
+ * Window-specific callback functions, see freeglut_callbacks.c
+ */
+FGAPI void    FGAPIENTRY glutMouseWheelFunc(void (* callback)(int, int, int, int));
+FGAPI void    FGAPIENTRY glutCloseFunc(void (* callback)(void));
+FGAPI void    FGAPIENTRY glutWMCloseFunc(void (* callback)(void));
+/* A. Donev: Also a destruction callback for menus */
+FGAPI void    FGAPIENTRY glutMenuDestroyFunc(void (* callback)(void));
+
+/*
+ * State setting and retrieval functions, see freeglut_state.c
+ */
+FGAPI void    FGAPIENTRY glutSetOption(GLenum option_flag, int value) ;
+/* A.Donev: User-data manipulation */
+FGAPI void   *FGAPIENTRY glutGetWindowData(void);
+FGAPI void    FGAPIENTRY glutSetWindowData(void *data);
+FGAPI void   *FGAPIENTRY glutGetMenuData(void);
+FGAPI void    FGAPIENTRY glutSetMenuData(void *data);
+
+/*
+ * Font stuff, see freeglut_font.c
+ */
+FGAPI int     FGAPIENTRY glutBitmapHeight(void *font);
+FGAPI GLfloat FGAPIENTRY glutStrokeHeight(void *font);
+FGAPI void    FGAPIENTRY glutBitmapString(void *font, const unsigned char *string);
+FGAPI void    FGAPIENTRY glutStrokeString(void *font, const unsigned char *string);
+
+/*
+ * Geometry functions, see freeglut_geometry.c
+ */
+FGAPI void    FGAPIENTRY glutWireRhombicDodecahedron(void);
+FGAPI void    FGAPIENTRY glutSolidRhombicDodecahedron(void);
+FGAPI void    FGAPIENTRY glutWireSierpinskiSponge(int num_levels, GLdouble offset[3], GLdouble scale) ;
+FGAPI void    FGAPIENTRY glutSolidSierpinskiSponge(int num_levels, GLdouble offset[3], GLdouble scale) ;
+FGAPI void    FGAPIENTRY glutWireCylinder(GLdouble radius, GLdouble height, GLint slices, GLint stacks);
+FGAPI void    FGAPIENTRY glutSolidCylinder(GLdouble radius, GLdouble height, GLint slices, GLint stacks);
+
+/*
+ * Extension functions, see freeglut_ext.c
+ */
+FGAPI void *FGAPIENTRY glutGetProcAddress(const char *procName);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/*** END OF FILE ***/
+
+#endif /* __FREEGLUT_EXT_H__ */

Common/GL/freeglut_std.h

@@ -0,0 +1,547 @@
+#ifndef  __FREEGLUT_STD_H__
+#define  __FREEGLUT_STD_H__
+
+/*
+ * freeglut_std.h
+ *
+ * The GLUT-compatible part of the freeglut library include file
+ *
+ * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>
+ * Creation date: Thu Dec 2 1999
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Under windows, we have to differentiate between static and dynamic libraries
+ */
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+#    include <windows.h>
+#    include <windowsx.h>
+#    include <mmsystem.h>
+#    define WINDOWS
+#ifdef FREEGLUT_STATIC
+#    define FGAPI
+#    define FGAPIENTRY
+
+#    pragma comment (lib, "freeglut_static.lib")    /* link with Win32 static freeglut lib */
+
+#else
+
+#        if defined(FREEGLUT_EXPORTS)
+#                define FGAPI __declspec(dllexport)
+/* #                define FGAPI */
+#        else
+#                define FGAPI __declspec(dllimport)
+#   pragma comment (lib, "freeglut.lib")    /* link with Win32 freeglut lib */
+#        endif
+#        define FGAPIENTRY __stdcall
+
+#endif
+
+#pragma comment (lib, "winmm.lib")       /* link with Windows MultiMedia lib */
+#pragma comment (lib, "user32.lib") /* link with Windows user lib */
+#pragma comment (lib, "gdi32.lib") /* link with Windows GDI lib */
+#pragma comment (lib, "opengl32.lib")    /* link with Microsoft OpenGL lib */
+#pragma comment (lib, "glu32.lib")       /* link with OpenGL Utility lib */
+
+
+#else
+#        define FGAPI
+#        define FGAPIENTRY
+#endif
+
+/*
+ * The freeglut and GLUT API versions
+ */
+#define  FREEGLUT             1
+#define  GLUT_API_VERSION     4
+#define  FREEGLUT_VERSION_2_0 1
+
+/*
+ * Always include OpenGL and GLU headers
+ */
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+/*
+ * GLUT API macro definitions -- the special key codes:
+ */
+#define  GLUT_KEY_F1                        0x0001
+#define  GLUT_KEY_F2                        0x0002
+#define  GLUT_KEY_F3                        0x0003
+#define  GLUT_KEY_F4                        0x0004
+#define  GLUT_KEY_F5                        0x0005
+#define  GLUT_KEY_F6                        0x0006
+#define  GLUT_KEY_F7                        0x0007
+#define  GLUT_KEY_F8                        0x0008
+#define  GLUT_KEY_F9                        0x0009
+#define  GLUT_KEY_F10                       0x000A
+#define  GLUT_KEY_F11                       0x000B
+#define  GLUT_KEY_F12                       0x000C
+#define  GLUT_KEY_LEFT                      0x0064
+#define  GLUT_KEY_UP                        0x0065
+#define  GLUT_KEY_RIGHT                     0x0066
+#define  GLUT_KEY_DOWN                      0x0067
+#define  GLUT_KEY_PAGE_UP                   0x0068
+#define  GLUT_KEY_PAGE_DOWN                 0x0069
+#define  GLUT_KEY_HOME                      0x006A
+#define  GLUT_KEY_END                       0x006B
+#define  GLUT_KEY_INSERT                    0x006C
+
+/*
+ * GLUT API macro definitions -- mouse state definitions
+ */
+#define  GLUT_LEFT_BUTTON                   0x0000
+#define  GLUT_MIDDLE_BUTTON                 0x0001
+#define  GLUT_RIGHT_BUTTON                  0x0002
+#define  GLUT_DOWN                          0x0000
+#define  GLUT_UP                            0x0001
+#define  GLUT_LEFT                          0x0000
+#define  GLUT_ENTERED                       0x0001
+
+/*
+ * GLUT API macro definitions -- the display mode definitions
+ */
+#define  GLUT_RGB                           0x0000
+#define  GLUT_RGBA                          0x0000
+#define  GLUT_INDEX                         0x0001
+#define  GLUT_SINGLE                        0x0000
+#define  GLUT_DOUBLE                        0x0002
+#define  GLUT_ACCUM                         0x0004
+#define  GLUT_ALPHA                         0x0008
+#define  GLUT_DEPTH                         0x0010
+#define  GLUT_STENCIL                       0x0020
+#define  GLUT_MULTISAMPLE                   0x0080
+#define  GLUT_STEREO                        0x0100
+#define  GLUT_LUMINANCE                     0x0200
+
+/*
+ * GLUT API macro definitions -- windows and menu related definitions
+ */
+#define  GLUT_MENU_NOT_IN_USE               0x0000
+#define  GLUT_MENU_IN_USE                   0x0001
+#define  GLUT_NOT_VISIBLE                   0x0000
+#define  GLUT_VISIBLE                       0x0001
+#define  GLUT_HIDDEN                        0x0000
+#define  GLUT_FULLY_RETAINED                0x0001
+#define  GLUT_PARTIALLY_RETAINED            0x0002
+#define  GLUT_FULLY_COVERED                 0x0003
+
+/*
+ * GLUT API macro definitions -- fonts definitions
+ *
+ * Steve Baker suggested to make it binary compatible with GLUT:
+ */
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+#   define  GLUT_STROKE_ROMAN               ((void *)0x0000)
+#   define  GLUT_STROKE_MONO_ROMAN          ((void *)0x0001)
+#   define  GLUT_BITMAP_9_BY_15             ((void *)0x0002)
+#   define  GLUT_BITMAP_8_BY_13             ((void *)0x0003)
+#   define  GLUT_BITMAP_TIMES_ROMAN_10      ((void *)0x0004)
+#   define  GLUT_BITMAP_TIMES_ROMAN_24      ((void *)0x0005)
+#   define  GLUT_BITMAP_HELVETICA_10        ((void *)0x0006)
+#   define  GLUT_BITMAP_HELVETICA_12        ((void *)0x0007)
+#   define  GLUT_BITMAP_HELVETICA_18        ((void *)0x0008)
+#else
+/*
+ * I don't really know if it's a good idea... But here it goes:
+ */
+extern void *glutStrokeRoman;
+extern void *glutStrokeMonoRoman;
+extern void *glutBitmap9By15;
+extern void *glutBitmap8By13;
+extern void *glutBitmapTimesRoman10;
+extern void *glutBitmapTimesRoman24;
+extern void *glutBitmapHelvetica10;
+extern void *glutBitmapHelvetica12;
+extern void *glutBitmapHelvetica18;
+
+/*
+ * Those pointers will be used by following definitions:
+ */
+#   define  GLUT_STROKE_ROMAN               ((void *) &glutStrokeRoman)
+#   define  GLUT_STROKE_MONO_ROMAN          ((void *) &glutStrokeMonoRoman)
+#   define  GLUT_BITMAP_9_BY_15             ((void *) &glutBitmap9By15)
+#   define  GLUT_BITMAP_8_BY_13             ((void *) &glutBitmap8By13)
+#   define  GLUT_BITMAP_TIMES_ROMAN_10      ((void *) &glutBitmapTimesRoman10)
+#   define  GLUT_BITMAP_TIMES_ROMAN_24      ((void *) &glutBitmapTimesRoman24)
+#   define  GLUT_BITMAP_HELVETICA_10        ((void *) &glutBitmapHelvetica10)
+#   define  GLUT_BITMAP_HELVETICA_12        ((void *) &glutBitmapHelvetica12)
+#   define  GLUT_BITMAP_HELVETICA_18        ((void *) &glutBitmapHelvetica18)
+#endif
+
+/*
+ * GLUT API macro definitions -- the glutGet parameters
+ */
+#define  GLUT_WINDOW_X                      0x0064
+#define  GLUT_WINDOW_Y                      0x0065
+#define  GLUT_WINDOW_WIDTH                  0x0066
+#define  GLUT_WINDOW_HEIGHT                 0x0067
+#define  GLUT_WINDOW_BUFFER_SIZE            0x0068
+#define  GLUT_WINDOW_STENCIL_SIZE           0x0069
+#define  GLUT_WINDOW_DEPTH_SIZE             0x006A
+#define  GLUT_WINDOW_RED_SIZE               0x006B
+#define  GLUT_WINDOW_GREEN_SIZE             0x006C
+#define  GLUT_WINDOW_BLUE_SIZE              0x006D
+#define  GLUT_WINDOW_ALPHA_SIZE             0x006E
+#define  GLUT_WINDOW_ACCUM_RED_SIZE         0x006F
+#define  GLUT_WINDOW_ACCUM_GREEN_SIZE       0x0070
+#define  GLUT_WINDOW_ACCUM_BLUE_SIZE        0x0071
+#define  GLUT_WINDOW_ACCUM_ALPHA_SIZE       0x0072
+#define  GLUT_WINDOW_DOUBLEBUFFER           0x0073
+#define  GLUT_WINDOW_RGBA                   0x0074
+#define  GLUT_WINDOW_PARENT                 0x0075
+#define  GLUT_WINDOW_NUM_CHILDREN           0x0076
+#define  GLUT_WINDOW_COLORMAP_SIZE          0x0077
+#define  GLUT_WINDOW_NUM_SAMPLES            0x0078
+#define  GLUT_WINDOW_STEREO                 0x0079
+#define  GLUT_WINDOW_CURSOR                 0x007A
+
+#define  GLUT_SCREEN_WIDTH                  0x00C8
+#define  GLUT_SCREEN_HEIGHT                 0x00C9
+#define  GLUT_SCREEN_WIDTH_MM               0x00CA
+#define  GLUT_SCREEN_HEIGHT_MM              0x00CB
+#define  GLUT_MENU_NUM_ITEMS                0x012C
+#define  GLUT_DISPLAY_MODE_POSSIBLE         0x0190
+#define  GLUT_INIT_WINDOW_X                 0x01F4
+#define  GLUT_INIT_WINDOW_Y                 0x01F5
+#define  GLUT_INIT_WINDOW_WIDTH             0x01F6
+#define  GLUT_INIT_WINDOW_HEIGHT            0x01F7
+#define  GLUT_INIT_DISPLAY_MODE             0x01F8
+#define  GLUT_ELAPSED_TIME                  0x02BC
+#define  GLUT_WINDOW_FORMAT_ID              0x007B
+#define  GLUT_INIT_STATE                    0x007C
+
+/*
+ * GLUT API macro definitions -- the glutDeviceGet parameters
+ */
+#define  GLUT_HAS_KEYBOARD                  0x0258
+#define  GLUT_HAS_MOUSE                     0x0259
+#define  GLUT_HAS_SPACEBALL                 0x025A
+#define  GLUT_HAS_DIAL_AND_BUTTON_BOX       0x025B
+#define  GLUT_HAS_TABLET                    0x025C
+#define  GLUT_NUM_MOUSE_BUTTONS             0x025D
+#define  GLUT_NUM_SPACEBALL_BUTTONS         0x025E
+#define  GLUT_NUM_BUTTON_BOX_BUTTONS        0x025F
+#define  GLUT_NUM_DIALS                     0x0260
+#define  GLUT_NUM_TABLET_BUTTONS            0x0261
+#define  GLUT_DEVICE_IGNORE_KEY_REPEAT      0x0262
+#define  GLUT_DEVICE_KEY_REPEAT             0x0263
+#define  GLUT_HAS_JOYSTICK                  0x0264
+#define  GLUT_OWNS_JOYSTICK                 0x0265
+#define  GLUT_JOYSTICK_BUTTONS              0x0266
+#define  GLUT_JOYSTICK_AXES                 0x0267
+#define  GLUT_JOYSTICK_POLL_RATE            0x0268
+
+/*
+ * GLUT API macro definitions -- the glutLayerGet parameters
+ */
+#define  GLUT_OVERLAY_POSSIBLE              0x0320
+#define  GLUT_LAYER_IN_USE                  0x0321
+#define  GLUT_HAS_OVERLAY                   0x0322
+#define  GLUT_TRANSPARENT_INDEX             0x0323
+#define  GLUT_NORMAL_DAMAGED                0x0324
+#define  GLUT_OVERLAY_DAMAGED               0x0325
+
+/*
+ * GLUT API macro definitions -- the glutVideoResizeGet parameters
+ */
+#define  GLUT_VIDEO_RESIZE_POSSIBLE         0x0384
+#define  GLUT_VIDEO_RESIZE_IN_USE           0x0385
+#define  GLUT_VIDEO_RESIZE_X_DELTA          0x0386
+#define  GLUT_VIDEO_RESIZE_Y_DELTA          0x0387
+#define  GLUT_VIDEO_RESIZE_WIDTH_DELTA      0x0388
+#define  GLUT_VIDEO_RESIZE_HEIGHT_DELTA     0x0389
+#define  GLUT_VIDEO_RESIZE_X                0x038A
+#define  GLUT_VIDEO_RESIZE_Y                0x038B
+#define  GLUT_VIDEO_RESIZE_WIDTH            0x038C
+#define  GLUT_VIDEO_RESIZE_HEIGHT           0x038D
+
+/*
+ * GLUT API macro definitions -- the glutUseLayer parameters
+ */
+#define  GLUT_NORMAL                        0x0000
+#define  GLUT_OVERLAY                       0x0001
+
+/*
+ * GLUT API macro definitions -- the glutGetModifiers parameters
+ */
+#define  GLUT_ACTIVE_SHIFT                  0x0001
+#define  GLUT_ACTIVE_CTRL                   0x0002
+#define  GLUT_ACTIVE_ALT                    0x0004
+
+/*
+ * GLUT API macro definitions -- the glutSetCursor parameters
+ */
+#define  GLUT_CURSOR_RIGHT_ARROW            0x0000
+#define  GLUT_CURSOR_LEFT_ARROW             0x0001
+#define  GLUT_CURSOR_INFO                   0x0002
+#define  GLUT_CURSOR_DESTROY                0x0003
+#define  GLUT_CURSOR_HELP                   0x0004
+#define  GLUT_CURSOR_CYCLE                  0x0005
+#define  GLUT_CURSOR_SPRAY                  0x0006
+#define  GLUT_CURSOR_WAIT                   0x0007
+#define  GLUT_CURSOR_TEXT                   0x0008
+#define  GLUT_CURSOR_CROSSHAIR              0x0009
+#define  GLUT_CURSOR_UP_DOWN                0x000A
+#define  GLUT_CURSOR_LEFT_RIGHT             0x000B
+#define  GLUT_CURSOR_TOP_SIDE               0x000C
+#define  GLUT_CURSOR_BOTTOM_SIDE            0x000D
+#define  GLUT_CURSOR_LEFT_SIDE              0x000E
+#define  GLUT_CURSOR_RIGHT_SIDE             0x000F
+#define  GLUT_CURSOR_TOP_LEFT_CORNER        0x0010
+#define  GLUT_CURSOR_TOP_RIGHT_CORNER       0x0011
+#define  GLUT_CURSOR_BOTTOM_RIGHT_CORNER    0x0012
+#define  GLUT_CURSOR_BOTTOM_LEFT_CORNER     0x0013
+#define  GLUT_CURSOR_INHERIT                0x0064
+#define  GLUT_CURSOR_NONE                   0x0065
+#define  GLUT_CURSOR_FULL_CROSSHAIR         0x0066
+
+/*
+ * GLUT API macro definitions -- RGB color component specification definitions
+ */
+#define  GLUT_RED                           0x0000
+#define  GLUT_GREEN                         0x0001
+#define  GLUT_BLUE                          0x0002
+
+/*
+ * GLUT API macro definitions -- additional keyboard and joystick definitions
+ */
+#define  GLUT_KEY_REPEAT_OFF                0x0000
+#define  GLUT_KEY_REPEAT_ON                 0x0001
+#define  GLUT_KEY_REPEAT_DEFAULT            0x0002
+
+#define  GLUT_JOYSTICK_BUTTON_A             0x0001
+#define  GLUT_JOYSTICK_BUTTON_B             0x0002
+#define  GLUT_JOYSTICK_BUTTON_C             0x0004
+#define  GLUT_JOYSTICK_BUTTON_D             0x0008
+
+/*
+ * GLUT API macro definitions -- game mode definitions
+ */
+#define  GLUT_GAME_MODE_ACTIVE              0x0000
+#define  GLUT_GAME_MODE_POSSIBLE            0x0001
+#define  GLUT_GAME_MODE_WIDTH               0x0002
+#define  GLUT_GAME_MODE_HEIGHT              0x0003
+#define  GLUT_GAME_MODE_PIXEL_DEPTH         0x0004
+#define  GLUT_GAME_MODE_REFRESH_RATE        0x0005
+#define  GLUT_GAME_MODE_DISPLAY_CHANGED     0x0006
+
+/*
+ * Initialization functions, see fglut_init.c
+ */
+FGAPI void    FGAPIENTRY glutInit(int *pargc, char **argv);
+FGAPI void    FGAPIENTRY glutInitWindowPosition(int x, int y);
+FGAPI void    FGAPIENTRY glutInitWindowSize(int width, int height);
+FGAPI void    FGAPIENTRY glutInitDisplayMode(unsigned int displayMode);
+FGAPI void    FGAPIENTRY glutInitDisplayString(const char *displayMode);
+
+/*
+ * Process loop function, see freeglut_main.c
+ */
+FGAPI void    FGAPIENTRY glutMainLoop(void);
+
+/*
+ * Window management functions, see freeglut_window.c
+ */
+FGAPI int     FGAPIENTRY glutCreateWindow(const char *title);
+FGAPI int     FGAPIENTRY glutCreateSubWindow(int window, int x, int y, int width, int height);
+FGAPI void    FGAPIENTRY glutDestroyWindow(int window);
+FGAPI void    FGAPIENTRY glutSetWindow(int window);
+FGAPI int     FGAPIENTRY glutGetWindow(void);
+FGAPI void    FGAPIENTRY glutSetWindowTitle(const char *title);
+FGAPI void    FGAPIENTRY glutSetIconTitle(const char *title);
+FGAPI void    FGAPIENTRY glutReshapeWindow(int width, int height);
+FGAPI void    FGAPIENTRY glutPositionWindow(int x, int y);
+FGAPI void    FGAPIENTRY glutShowWindow(void);
+FGAPI void    FGAPIENTRY glutHideWindow(void);
+FGAPI void    FGAPIENTRY glutIconifyWindow(void);
+FGAPI void    FGAPIENTRY glutPushWindow(void);
+FGAPI void    FGAPIENTRY glutPopWindow(void);
+FGAPI void    FGAPIENTRY glutFullScreen(void);
+
+/*
+ * Display-connected functions, see freeglut_display.c
+ */
+FGAPI void    FGAPIENTRY glutPostWindowRedisplay(int window);
+FGAPI void    FGAPIENTRY glutPostRedisplay(void);
+FGAPI void    FGAPIENTRY glutSwapBuffers(void);
+
+/*
+ * Mouse cursor functions, see freeglut_cursor.c
+ */
+FGAPI void    FGAPIENTRY glutWarpPointer(int x, int y);
+FGAPI void    FGAPIENTRY glutSetCursor(int cursor);
+
+/*
+ * Overlay stuff, see freeglut_overlay.c
+ */
+FGAPI void    FGAPIENTRY glutEstablishOverlay(void);
+FGAPI void    FGAPIENTRY glutRemoveOverlay(void);
+FGAPI void    FGAPIENTRY glutUseLayer(GLenum layer);
+FGAPI void    FGAPIENTRY glutPostOverlayRedisplay(void);
+FGAPI void    FGAPIENTRY glutPostWindowOverlayRedisplay(int window);
+FGAPI void    FGAPIENTRY glutShowOverlay(void);
+FGAPI void    FGAPIENTRY glutHideOverlay(void);
+
+/*
+ * Menu stuff, see freeglut_menu.c
+ */
+FGAPI int     FGAPIENTRY glutCreateMenu(void (* callback)(int menu));
+FGAPI void    FGAPIENTRY glutDestroyMenu(int menu);
+FGAPI int     FGAPIENTRY glutGetMenu(void);
+FGAPI void    FGAPIENTRY glutSetMenu(int menu);
+FGAPI void    FGAPIENTRY glutAddMenuEntry(const char *label, int value);
+FGAPI void    FGAPIENTRY glutAddSubMenu(const char *label, int subMenu);
+FGAPI void    FGAPIENTRY glutChangeToMenuEntry(int item, const char *label, int value);
+FGAPI void    FGAPIENTRY glutChangeToSubMenu(int item, const char *label, int value);
+FGAPI void    FGAPIENTRY glutRemoveMenuItem(int item);
+FGAPI void    FGAPIENTRY glutAttachMenu(int button);
+FGAPI void    FGAPIENTRY glutDetachMenu(int button);
+
+/*
+ * Global callback functions, see freeglut_callbacks.c
+ */
+FGAPI void    FGAPIENTRY glutTimerFunc(unsigned int time, void (* callback)(int), int value);
+FGAPI void    FGAPIENTRY glutIdleFunc(void (* callback)(void));
+
+/*
+ * Window-specific callback functions, see freeglut_callbacks.c
+ */
+FGAPI void    FGAPIENTRY glutKeyboardFunc(void (* callback)(unsigned char, int, int));
+FGAPI void    FGAPIENTRY glutSpecialFunc(void (* callback)(int, int, int));
+FGAPI void    FGAPIENTRY glutReshapeFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutVisibilityFunc(void (* callback)(int));
+FGAPI void    FGAPIENTRY glutDisplayFunc(void (* callback)(void));
+FGAPI void    FGAPIENTRY glutMouseFunc(void (* callback)(int, int, int, int));
+FGAPI void    FGAPIENTRY glutMotionFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutPassiveMotionFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutEntryFunc(void (* callback)(int));
+
+FGAPI void    FGAPIENTRY glutKeyboardUpFunc(void (* callback)(unsigned char, int, int));
+FGAPI void    FGAPIENTRY glutSpecialUpFunc(void (* callback)(int, int, int));
+FGAPI void    FGAPIENTRY glutJoystickFunc(void (* callback)(unsigned int, int, int, int), int pollInterval);
+FGAPI void    FGAPIENTRY glutMenuStateFunc(void (* callback)(int));
+FGAPI void    FGAPIENTRY glutMenuStatusFunc(void (* callback)(int, int, int));
+FGAPI void    FGAPIENTRY glutOverlayDisplayFunc(void (* callback)(void));
+FGAPI void    FGAPIENTRY glutWindowStatusFunc(void (* callback)(int));
+
+FGAPI void    FGAPIENTRY glutSpaceballMotionFunc(void (* callback)(int, int, int));
+FGAPI void    FGAPIENTRY glutSpaceballRotateFunc(void (* callback)(int, int, int));
+FGAPI void    FGAPIENTRY glutSpaceballButtonFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutButtonBoxFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutDialsFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutTabletMotionFunc(void (* callback)(int, int));
+FGAPI void    FGAPIENTRY glutTabletButtonFunc(void (* callback)(int, int, int, int));
+
+/*
+ * State setting and retrieval functions, see freeglut_state.c
+ */
+FGAPI int     FGAPIENTRY glutGet(GLenum query);
+FGAPI int     FGAPIENTRY glutDeviceGet(GLenum query);
+FGAPI int     FGAPIENTRY glutGetModifiers(void);
+FGAPI int     FGAPIENTRY glutLayerGet(GLenum query);
+
+/*
+ * Font stuff, see freeglut_font.c
+ */
+FGAPI void    FGAPIENTRY glutBitmapCharacter(void *font, int character);
+FGAPI int     FGAPIENTRY glutBitmapWidth(void *font, int character);
+FGAPI void    FGAPIENTRY glutStrokeCharacter(void *font, int character);
+FGAPI int     FGAPIENTRY glutStrokeWidth(void *font, int character);
+FGAPI int     FGAPIENTRY glutBitmapLength(void *font, const unsigned char *string);
+FGAPI int     FGAPIENTRY glutStrokeLength(void *font, const unsigned char *string);
+
+/*
+ * Geometry functions, see freeglut_geometry.c
+ */
+FGAPI void    FGAPIENTRY glutWireCube(GLdouble size);
+FGAPI void    FGAPIENTRY glutSolidCube(GLdouble size);
+FGAPI void    FGAPIENTRY glutWireSphere(GLdouble radius, GLint slices, GLint stacks);
+FGAPI void    FGAPIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks);
+FGAPI void    FGAPIENTRY glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
+FGAPI void    FGAPIENTRY glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
+
+FGAPI void    FGAPIENTRY glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
+FGAPI void    FGAPIENTRY glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
+FGAPI void    FGAPIENTRY glutWireDodecahedron(void);
+FGAPI void    FGAPIENTRY glutSolidDodecahedron(void);
+FGAPI void    FGAPIENTRY glutWireOctahedron(void);
+FGAPI void    FGAPIENTRY glutSolidOctahedron(void);
+FGAPI void    FGAPIENTRY glutWireTetrahedron(void);
+FGAPI void    FGAPIENTRY glutSolidTetrahedron(void);
+FGAPI void    FGAPIENTRY glutWireIcosahedron(void);
+FGAPI void    FGAPIENTRY glutSolidIcosahedron(void);
+
+/*
+ * Teapot rendering functions, found in freeglut_teapot.c
+ */
+FGAPI void    FGAPIENTRY glutWireTeapot(GLdouble size);
+FGAPI void    FGAPIENTRY glutSolidTeapot(GLdouble size);
+
+/*
+ * Game mode functions, see freeglut_gamemode.c
+ */
+FGAPI void    FGAPIENTRY glutGameModeString(const char *string);
+FGAPI int     FGAPIENTRY glutEnterGameMode(void);
+FGAPI void    FGAPIENTRY glutLeaveGameMode(void);
+FGAPI int     FGAPIENTRY glutGameModeGet(GLenum query);
+
+/*
+ * Video resize functions, see freeglut_videoresize.c
+ */
+FGAPI int     FGAPIENTRY glutVideoResizeGet(GLenum query);
+FGAPI void    FGAPIENTRY glutSetupVideoResizing(void);
+FGAPI void    FGAPIENTRY glutStopVideoResizing(void);
+FGAPI void    FGAPIENTRY glutVideoResize(int x, int y, int width, int height);
+FGAPI void    FGAPIENTRY glutVideoPan(int x, int y, int width, int height);
+
+/*
+ * Colormap functions, see freeglut_misc.c
+ */
+FGAPI void    FGAPIENTRY glutSetColor(int color, GLfloat red, GLfloat green, GLfloat blue);
+FGAPI GLfloat FGAPIENTRY glutGetColor(int color, int component);
+FGAPI void    FGAPIENTRY glutCopyColormap(int window);
+
+/*
+ * Misc keyboard and joystick functions, see freeglut_misc.c
+ */
+FGAPI void    FGAPIENTRY glutIgnoreKeyRepeat(int ignore);
+FGAPI void    FGAPIENTRY glutSetKeyRepeat(int repeatMode);    /* DEPRECATED 11/4/02 - Do not use */
+FGAPI void    FGAPIENTRY glutForceJoystickFunc(void);
+
+/*
+ * Misc functions, see freeglut_misc.c
+ */
+FGAPI int     FGAPIENTRY glutExtensionSupported(const char *extension);
+FGAPI void    FGAPIENTRY glutReportErrors(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+/*** END OF FILE ***/
+
+#endif /* __FREEGLUT_STD_H__ */
+

Common/GL/glut.h

@@ -0,0 +1,597 @@
+#ifndef __glut_h__
+#define __glut_h__
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1998. */
+
+/* This program is freely distributable without licensing fees  and is
+   provided without guarantee or warrantee expressed or  implied. This
+   program is -not- in the public domain. */
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+
+/* GLUT 3.7 now tries to avoid including <windows.h>
+   to avoid name space pollution, but Win32's <GL/gl.h>
+   needs APIENTRY and WINGDIAPI defined properly. */
+# if 0
+#  define  WIN32_LEAN_AND_MEAN
+#  include <windows.h>
+# else
+/* XXX This is from Win32's <windef.h> */
+#  ifndef APIENTRY
+#   define GLUT_APIENTRY_DEFINED
+#   if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)
+#    define APIENTRY    __stdcall
+#   else
+#    define APIENTRY
+#   endif
+#  endif
+/* XXX This is from Win32's <winnt.h> */
+#  ifndef CALLBACK
+#   if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS)
+#    define CALLBACK __stdcall
+#   else
+#    define CALLBACK
+#   endif
+#  endif
+/* XXX This is from Win32's <wingdi.h> and <winnt.h> */
+#  ifndef WINGDIAPI
+#   define GLUT_WINGDIAPI_DEFINED
+#   define WINGDIAPI __declspec(dllimport)
+#  endif
+/* XXX This is from Win32's <ctype.h> */
+#  ifndef _WCHAR_T_DEFINED
+typedef unsigned short wchar_t;
+#   define _WCHAR_T_DEFINED
+#  endif
+# endif
+
+#pragma comment (lib, "winmm.lib")     /* link with Windows MultiMedia lib */
+#pragma comment (lib, "opengl32.lib")  /* link with Microsoft OpenGL lib */
+#pragma comment (lib, "glu32.lib")     /* link with OpenGL Utility lib */
+#pragma message("Note: including lib: glut32.lib\n")
+#pragma comment (lib, "glut32.lib")    /* link with Win32 GLUT lib */
+
+#pragma warning (disable:4244)  /* Disable bogus conversion warnings. */
+#pragma warning (disable:4305)  /* VC++ 5.0 version of above warning. */
+
+#endif
+
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+/* define APIENTRY and CALLBACK to null string if we aren't on Win32 */
+#if !defined(WIN32)
+#define APIENTRY
+#define GLUT_APIENTRY_DEFINED
+#define CALLBACK
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ GLUT API revision history:
+
+ GLUT_API_VERSION is updated to reflect incompatible GLUT
+ API changes (interface changes, semantic changes, deletions,
+ or additions).
+
+ GLUT_API_VERSION=1  First public release of GLUT.  11/29/94
+
+ GLUT_API_VERSION=2  Added support for OpenGL/GLX multisampling,
+ extension.  Supports new input devices like tablet, dial and button
+ box, and Spaceball.  Easy to query OpenGL extensions.
+
+ GLUT_API_VERSION=3  glutMenuStatus added.
+
+ GLUT_API_VERSION=4  glutInitDisplayString, glutWarpPointer,
+ glutBitmapLength, glutStrokeLength, glutWindowStatusFunc, dynamic
+ video resize subAPI, glutPostWindowRedisplay, glutKeyboardUpFunc,
+ glutSpecialUpFunc, glutIgnoreKeyRepeat, glutSetKeyRepeat,
+ glutJoystickFunc, glutForceJoystickFunc (NOT FINALIZED!).
+**/
+#ifndef GLUT_API_VERSION  /* allow this to be overriden */
+#define GLUT_API_VERSION        3
+#endif
+
+/**
+ GLUT implementation revision history:
+
+ GLUT_XLIB_IMPLEMENTATION is updated to reflect both GLUT
+ API revisions and implementation revisions (ie, bug fixes).
+
+ GLUT_XLIB_IMPLEMENTATION=1  mjk's first public release of
+ GLUT Xlib-based implementation.  11/29/94
+
+ GLUT_XLIB_IMPLEMENTATION=2  mjk's second public release of
+ GLUT Xlib-based implementation providing GLUT version 2
+ interfaces.
+
+ GLUT_XLIB_IMPLEMENTATION=3  mjk's GLUT 2.2 images. 4/17/95
+
+ GLUT_XLIB_IMPLEMENTATION=4  mjk's GLUT 2.3 images. 6/?/95
+
+ GLUT_XLIB_IMPLEMENTATION=5  mjk's GLUT 3.0 images. 10/?/95
+
+ GLUT_XLIB_IMPLEMENTATION=7  mjk's GLUT 3.1+ with glutWarpPoitner.  7/24/96
+
+ GLUT_XLIB_IMPLEMENTATION=8  mjk's GLUT 3.1+ with glutWarpPoitner
+ and video resize.  1/3/97
+
+ GLUT_XLIB_IMPLEMENTATION=9 mjk's GLUT 3.4 release with early GLUT 4 routines.
+
+ GLUT_XLIB_IMPLEMENTATION=11 Mesa 2.5's GLUT 3.6 release.
+
+ GLUT_XLIB_IMPLEMENTATION=12 mjk's GLUT 3.6 release with early GLUT 4 routines + signal handling.
+
+ GLUT_XLIB_IMPLEMENTATION=13 mjk's GLUT 3.7 release with GameGLUT support.
+**/
+#ifndef GLUT_XLIB_IMPLEMENTATION  /* Allow this to be overriden. */
+#define GLUT_XLIB_IMPLEMENTATION    13
+#endif
+
+/* Display mode bit masks. */
+#define GLUT_RGB            0
+#define GLUT_RGBA           GLUT_RGB
+#define GLUT_INDEX          1
+#define GLUT_SINGLE         0
+#define GLUT_DOUBLE         2
+#define GLUT_ACCUM          4
+#define GLUT_ALPHA          8
+#define GLUT_DEPTH          16
+#define GLUT_STENCIL            32
+#if (GLUT_API_VERSION >= 2)
+#define GLUT_MULTISAMPLE        128
+#define GLUT_STEREO         256
+#endif
+#if (GLUT_API_VERSION >= 3)
+#define GLUT_LUMINANCE          512
+#endif
+
+/* Mouse buttons. */
+#define GLUT_LEFT_BUTTON        0
+#define GLUT_MIDDLE_BUTTON      1
+#define GLUT_RIGHT_BUTTON       2
+
+/* Mouse button  state. */
+#define GLUT_DOWN           0
+#define GLUT_UP             1
+
+#if (GLUT_API_VERSION >= 2)
+/* function keys */
+#define GLUT_KEY_F1         1
+#define GLUT_KEY_F2         2
+#define GLUT_KEY_F3         3
+#define GLUT_KEY_F4         4
+#define GLUT_KEY_F5         5
+#define GLUT_KEY_F6         6
+#define GLUT_KEY_F7         7
+#define GLUT_KEY_F8         8
+#define GLUT_KEY_F9         9
+#define GLUT_KEY_F10            10
+#define GLUT_KEY_F11            11
+#define GLUT_KEY_F12            12
+/* directional keys */
+#define GLUT_KEY_LEFT           100
+#define GLUT_KEY_UP         101
+#define GLUT_KEY_RIGHT          102
+#define GLUT_KEY_DOWN           103
+#define GLUT_KEY_PAGE_UP        104
+#define GLUT_KEY_PAGE_DOWN      105
+#define GLUT_KEY_HOME           106
+#define GLUT_KEY_END            107
+#define GLUT_KEY_INSERT         108
+#endif
+
+/* Entry/exit  state. */
+#define GLUT_LEFT           0
+#define GLUT_ENTERED            1
+
+/* Menu usage  state. */
+#define GLUT_MENU_NOT_IN_USE        0
+#define GLUT_MENU_IN_USE        1
+
+/* Visibility  state. */
+#define GLUT_NOT_VISIBLE        0
+#define GLUT_VISIBLE            1
+
+/* Window status  state. */
+#define GLUT_HIDDEN         0
+#define GLUT_FULLY_RETAINED     1
+#define GLUT_PARTIALLY_RETAINED     2
+#define GLUT_FULLY_COVERED      3
+
+/* Color index component selection values. */
+#define GLUT_RED            0
+#define GLUT_GREEN          1
+#define GLUT_BLUE           2
+
+/* Layers for use. */
+#define GLUT_NORMAL         0
+#define GLUT_OVERLAY            1
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+/* Stroke font constants (use these in GLUT program). */
+#define GLUT_STROKE_ROMAN       ((void*)0)
+#define GLUT_STROKE_MONO_ROMAN      ((void*)1)
+
+/* Bitmap font constants (use these in GLUT program). */
+#define GLUT_BITMAP_9_BY_15     ((void*)2)
+#define GLUT_BITMAP_8_BY_13     ((void*)3)
+#define GLUT_BITMAP_TIMES_ROMAN_10  ((void*)4)
+#define GLUT_BITMAP_TIMES_ROMAN_24  ((void*)5)
+#if (GLUT_API_VERSION >= 3)
+#define GLUT_BITMAP_HELVETICA_10    ((void*)6)
+#define GLUT_BITMAP_HELVETICA_12    ((void*)7)
+#define GLUT_BITMAP_HELVETICA_18    ((void*)8)
+#endif
+#else
+/* Stroke font opaque addresses (use constants instead in source code). */
+extern void *glutStrokeRoman;
+extern void *glutStrokeMonoRoman;
+
+/* Stroke font constants (use these in GLUT program). */
+#define GLUT_STROKE_ROMAN       (&glutStrokeRoman)
+#define GLUT_STROKE_MONO_ROMAN      (&glutStrokeMonoRoman)
+
+/* Bitmap font opaque addresses (use constants instead in source code). */
+extern void *glutBitmap9By15;
+extern void *glutBitmap8By13;
+extern void *glutBitmapTimesRoman10;
+extern void *glutBitmapTimesRoman24;
+extern void *glutBitmapHelvetica10;
+extern void *glutBitmapHelvetica12;
+extern void *glutBitmapHelvetica18;
+
+/* Bitmap font constants (use these in GLUT program). */
+#define GLUT_BITMAP_9_BY_15     (&glutBitmap9By15)
+#define GLUT_BITMAP_8_BY_13     (&glutBitmap8By13)
+#define GLUT_BITMAP_TIMES_ROMAN_10  (&glutBitmapTimesRoman10)
+#define GLUT_BITMAP_TIMES_ROMAN_24  (&glutBitmapTimesRoman24)
+#if (GLUT_API_VERSION >= 3)
+#define GLUT_BITMAP_HELVETICA_10    (&glutBitmapHelvetica10)
+#define GLUT_BITMAP_HELVETICA_12    (&glutBitmapHelvetica12)
+#define GLUT_BITMAP_HELVETICA_18    (&glutBitmapHelvetica18)
+#endif
+#endif
+
+/* glutGet parameters. */
+#define GLUT_WINDOW_X           100
+#define GLUT_WINDOW_Y           101
+#define GLUT_WINDOW_WIDTH       102
+#define GLUT_WINDOW_HEIGHT      103
+#define GLUT_WINDOW_BUFFER_SIZE     104
+#define GLUT_WINDOW_STENCIL_SIZE    105
+#define GLUT_WINDOW_DEPTH_SIZE      106
+#define GLUT_WINDOW_RED_SIZE        107
+#define GLUT_WINDOW_GREEN_SIZE      108
+#define GLUT_WINDOW_BLUE_SIZE       109
+#define GLUT_WINDOW_ALPHA_SIZE      110
+#define GLUT_WINDOW_ACCUM_RED_SIZE  111
+#define GLUT_WINDOW_ACCUM_GREEN_SIZE    112
+#define GLUT_WINDOW_ACCUM_BLUE_SIZE 113
+#define GLUT_WINDOW_ACCUM_ALPHA_SIZE    114
+#define GLUT_WINDOW_DOUBLEBUFFER    115
+#define GLUT_WINDOW_RGBA        116
+#define GLUT_WINDOW_PARENT      117
+#define GLUT_WINDOW_NUM_CHILDREN    118
+#define GLUT_WINDOW_COLORMAP_SIZE   119
+#if (GLUT_API_VERSION >= 2)
+#define GLUT_WINDOW_NUM_SAMPLES     120
+#define GLUT_WINDOW_STEREO      121
+#endif
+#if (GLUT_API_VERSION >= 3)
+#define GLUT_WINDOW_CURSOR      122
+#endif
+#define GLUT_SCREEN_WIDTH       200
+#define GLUT_SCREEN_HEIGHT      201
+#define GLUT_SCREEN_WIDTH_MM        202
+#define GLUT_SCREEN_HEIGHT_MM       203
+#define GLUT_MENU_NUM_ITEMS     300
+#define GLUT_DISPLAY_MODE_POSSIBLE  400
+#define GLUT_INIT_WINDOW_X      500
+#define GLUT_INIT_WINDOW_Y      501
+#define GLUT_INIT_WINDOW_WIDTH      502
+#define GLUT_INIT_WINDOW_HEIGHT     503
+#define GLUT_INIT_DISPLAY_MODE      504
+#if (GLUT_API_VERSION >= 2)
+#define GLUT_ELAPSED_TIME       700
+#endif
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
+#define GLUT_WINDOW_FORMAT_ID       123
+#endif
+
+#if (GLUT_API_VERSION >= 2)
+/* glutDeviceGet parameters. */
+#define GLUT_HAS_KEYBOARD       600
+#define GLUT_HAS_MOUSE          601
+#define GLUT_HAS_SPACEBALL      602
+#define GLUT_HAS_DIAL_AND_BUTTON_BOX    603
+#define GLUT_HAS_TABLET         604
+#define GLUT_NUM_MOUSE_BUTTONS      605
+#define GLUT_NUM_SPACEBALL_BUTTONS  606
+#define GLUT_NUM_BUTTON_BOX_BUTTONS 607
+#define GLUT_NUM_DIALS          608
+#define GLUT_NUM_TABLET_BUTTONS     609
+#endif
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
+#define GLUT_DEVICE_IGNORE_KEY_REPEAT   610
+#define GLUT_DEVICE_KEY_REPEAT          611
+#define GLUT_HAS_JOYSTICK       612
+#define GLUT_OWNS_JOYSTICK      613
+#define GLUT_JOYSTICK_BUTTONS       614
+#define GLUT_JOYSTICK_AXES      615
+#define GLUT_JOYSTICK_POLL_RATE     616
+#endif
+
+#if (GLUT_API_VERSION >= 3)
+/* glutLayerGet parameters. */
+#define GLUT_OVERLAY_POSSIBLE           800
+#define GLUT_LAYER_IN_USE       801
+#define GLUT_HAS_OVERLAY        802
+#define GLUT_TRANSPARENT_INDEX      803
+#define GLUT_NORMAL_DAMAGED     804
+#define GLUT_OVERLAY_DAMAGED        805
+
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+/* glutVideoResizeGet parameters. */
+#define GLUT_VIDEO_RESIZE_POSSIBLE  900
+#define GLUT_VIDEO_RESIZE_IN_USE    901
+#define GLUT_VIDEO_RESIZE_X_DELTA   902
+#define GLUT_VIDEO_RESIZE_Y_DELTA   903
+#define GLUT_VIDEO_RESIZE_WIDTH_DELTA   904
+#define GLUT_VIDEO_RESIZE_HEIGHT_DELTA  905
+#define GLUT_VIDEO_RESIZE_X     906
+#define GLUT_VIDEO_RESIZE_Y     907
+#define GLUT_VIDEO_RESIZE_WIDTH     908
+#define GLUT_VIDEO_RESIZE_HEIGHT    909
+#endif
+
+/* glutUseLayer parameters. */
+#define GLUT_NORMAL         0
+#define GLUT_OVERLAY            1
+
+/* glutGetModifiers return mask. */
+#define GLUT_ACTIVE_SHIFT               1
+#define GLUT_ACTIVE_CTRL                2
+#define GLUT_ACTIVE_ALT                 4
+
+/* glutSetCursor parameters. */
+/* Basic arrows. */
+#define GLUT_CURSOR_RIGHT_ARROW     0
+#define GLUT_CURSOR_LEFT_ARROW      1
+/* Symbolic cursor shapes. */
+#define GLUT_CURSOR_INFO        2
+#define GLUT_CURSOR_DESTROY     3
+#define GLUT_CURSOR_HELP        4
+#define GLUT_CURSOR_CYCLE       5
+#define GLUT_CURSOR_SPRAY       6
+#define GLUT_CURSOR_WAIT        7
+#define GLUT_CURSOR_TEXT        8
+#define GLUT_CURSOR_CROSSHAIR       9
+/* Directional cursors. */
+#define GLUT_CURSOR_UP_DOWN     10
+#define GLUT_CURSOR_LEFT_RIGHT      11
+/* Sizing cursors. */
+#define GLUT_CURSOR_TOP_SIDE        12
+#define GLUT_CURSOR_BOTTOM_SIDE     13
+#define GLUT_CURSOR_LEFT_SIDE       14
+#define GLUT_CURSOR_RIGHT_SIDE      15
+#define GLUT_CURSOR_TOP_LEFT_CORNER 16
+#define GLUT_CURSOR_TOP_RIGHT_CORNER    17
+#define GLUT_CURSOR_BOTTOM_RIGHT_CORNER 18
+#define GLUT_CURSOR_BOTTOM_LEFT_CORNER  19
+/* Inherit from parent window. */
+#define GLUT_CURSOR_INHERIT     100
+/* Blank cursor. */
+#define GLUT_CURSOR_NONE        101
+/* Fullscreen crosshair (if available). */
+#define GLUT_CURSOR_FULL_CROSSHAIR  102
+#endif
+
+/* GLUT initialization sub-API. */
+extern void APIENTRY glutInit(int *argcp, char **argv);
+extern void APIENTRY glutInitDisplayMode(unsigned int mode);
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+extern void APIENTRY glutInitDisplayString(const char *string);
+#endif
+extern void APIENTRY glutInitWindowPosition(int x, int y);
+extern void APIENTRY glutInitWindowSize(int width, int height);
+extern void APIENTRY glutMainLoop(void);
+
+/* GLUT window sub-API. */
+extern int APIENTRY glutCreateWindow(const char *title);
+extern int APIENTRY glutCreateSubWindow(int win, int x, int y, int width, int height);
+extern void APIENTRY glutDestroyWindow(int win);
+extern void APIENTRY glutPostRedisplay(void);
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11)
+extern void APIENTRY glutPostWindowRedisplay(int win);
+#endif
+extern void APIENTRY glutSwapBuffers(void);
+extern int APIENTRY glutGetWindow(void);
+extern void APIENTRY glutSetWindow(int win);
+extern void APIENTRY glutSetWindowTitle(const char *title);
+extern void APIENTRY glutSetIconTitle(const char *title);
+extern void APIENTRY glutPositionWindow(int x, int y);
+extern void APIENTRY glutReshapeWindow(int width, int height);
+extern void APIENTRY glutPopWindow(void);
+extern void APIENTRY glutPushWindow(void);
+extern void APIENTRY glutIconifyWindow(void);
+extern void APIENTRY glutShowWindow(void);
+extern void APIENTRY glutHideWindow(void);
+#if (GLUT_API_VERSION >= 3)
+extern void APIENTRY glutFullScreen(void);
+extern void APIENTRY glutSetCursor(int cursor);
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+extern void APIENTRY glutWarpPointer(int x, int y);
+#endif
+
+/* GLUT overlay sub-API. */
+extern void APIENTRY glutEstablishOverlay(void);
+extern void APIENTRY glutRemoveOverlay(void);
+extern void APIENTRY glutUseLayer(GLenum layer);
+extern void APIENTRY glutPostOverlayRedisplay(void);
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11)
+extern void APIENTRY glutPostWindowOverlayRedisplay(int win);
+#endif
+extern void APIENTRY glutShowOverlay(void);
+extern void APIENTRY glutHideOverlay(void);
+#endif
+
+/* GLUT menu sub-API. */
+extern int APIENTRY glutCreateMenu(void ( *)(int));
+extern void APIENTRY glutDestroyMenu(int menu);
+extern int APIENTRY glutGetMenu(void);
+extern void APIENTRY glutSetMenu(int menu);
+extern void APIENTRY glutAddMenuEntry(const char *label, int value);
+extern void APIENTRY glutAddSubMenu(const char *label, int submenu);
+extern void APIENTRY glutChangeToMenuEntry(int item, const char *label, int value);
+extern void APIENTRY glutChangeToSubMenu(int item, const char *label, int submenu);
+extern void APIENTRY glutRemoveMenuItem(int item);
+extern void APIENTRY glutAttachMenu(int button);
+extern void APIENTRY glutDetachMenu(int button);
+
+/* GLUT window callback sub-API. */
+extern void APIENTRY glutDisplayFunc(void (*func)(void));
+extern void APIENTRY glutReshapeFunc(void (*func)(int width, int height));
+extern void APIENTRY glutKeyboardFunc(void (*func)(unsigned char key, int x, int y));
+extern void APIENTRY glutMouseFunc(void (*func)(int button, int state, int x, int y));
+extern void APIENTRY glutMotionFunc(void (*func)(int x, int y));
+extern void APIENTRY glutPassiveMotionFunc(void (*func)(int x, int y));
+extern void APIENTRY glutEntryFunc(void (*func)(int state));
+extern void APIENTRY glutVisibilityFunc(void (*func)(int state));
+extern void APIENTRY glutIdleFunc(void (*func)(void));
+extern void APIENTRY glutTimerFunc(unsigned int millis, void (*func)(int value), int value);
+extern void APIENTRY glutMenuStateFunc(void (*func)(int state));
+#if (GLUT_API_VERSION >= 2)
+extern void APIENTRY glutSpecialFunc(void (*func)(int key, int x, int y));
+extern void APIENTRY glutSpaceballMotionFunc(void (*func)(int x, int y, int z));
+extern void APIENTRY glutSpaceballRotateFunc(void (*func)(int x, int y, int z));
+extern void APIENTRY glutSpaceballButtonFunc(void (*func)(int button, int state));
+extern void APIENTRY glutButtonBoxFunc(void (*func)(int button, int state));
+extern void APIENTRY glutDialsFunc(void (*func)(int dial, int value));
+extern void APIENTRY glutTabletMotionFunc(void (*func)(int x, int y));
+extern void APIENTRY glutTabletButtonFunc(void (*func)(int button, int state, int x, int y));
+#if (GLUT_API_VERSION >= 3)
+extern void APIENTRY glutMenuStatusFunc(void (*func)(int status, int x, int y));
+extern void APIENTRY glutOverlayDisplayFunc(void (*func)(void));
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+extern void APIENTRY glutWindowStatusFunc(void (*func)(int state));
+#endif
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
+extern void APIENTRY glutKeyboardUpFunc(void (*func)(unsigned char key, int x, int y));
+extern void APIENTRY glutSpecialUpFunc(void (*func)(int key, int x, int y));
+extern void APIENTRY glutJoystickFunc(void (*func)(unsigned int buttonMask, int x, int y, int z), int pollInterval);
+#endif
+#endif
+#endif
+
+/* GLUT color index sub-API. */
+extern void APIENTRY glutSetColor(int, GLfloat red, GLfloat green, GLfloat blue);
+extern GLfloat APIENTRY glutGetColor(int ndx, int component);
+extern void APIENTRY glutCopyColormap(int win);
+
+/* GLUT state retrieval sub-API. */
+extern int APIENTRY glutGet(GLenum type);
+extern int APIENTRY glutDeviceGet(GLenum type);
+#if (GLUT_API_VERSION >= 2)
+/* GLUT extension support sub-API */
+extern int APIENTRY glutExtensionSupported(const char *name);
+#endif
+#if (GLUT_API_VERSION >= 3)
+extern int APIENTRY glutGetModifiers(void);
+extern int APIENTRY glutLayerGet(GLenum type);
+#endif
+
+/* GLUT font sub-API */
+extern void APIENTRY glutBitmapCharacter(void *font, int character);
+extern int APIENTRY glutBitmapWidth(void *font, int character);
+extern void APIENTRY glutStrokeCharacter(void *font, int character);
+extern int APIENTRY glutStrokeWidth(void *font, int character);
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+extern int APIENTRY glutBitmapLength(void *font, const unsigned char *string);
+extern int APIENTRY glutStrokeLength(void *font, const unsigned char *string);
+#endif
+
+/* GLUT pre-built models sub-API */
+extern void APIENTRY glutWireSphere(GLdouble radius, GLint slices, GLint stacks);
+extern void APIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks);
+extern void APIENTRY glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
+extern void APIENTRY glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
+extern void APIENTRY glutWireCube(GLdouble size);
+extern void APIENTRY glutSolidCube(GLdouble size);
+extern void APIENTRY glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
+extern void APIENTRY glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
+extern void APIENTRY glutWireDodecahedron(void);
+extern void APIENTRY glutSolidDodecahedron(void);
+extern void APIENTRY glutWireTeapot(GLdouble size);
+extern void APIENTRY glutSolidTeapot(GLdouble size);
+extern void APIENTRY glutWireOctahedron(void);
+extern void APIENTRY glutSolidOctahedron(void);
+extern void APIENTRY glutWireTetrahedron(void);
+extern void APIENTRY glutSolidTetrahedron(void);
+extern void APIENTRY glutWireIcosahedron(void);
+extern void APIENTRY glutSolidIcosahedron(void);
+
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+/* GLUT video resize sub-API. */
+extern int APIENTRY glutVideoResizeGet(GLenum param);
+extern void APIENTRY glutSetupVideoResizing(void);
+extern void APIENTRY glutStopVideoResizing(void);
+extern void APIENTRY glutVideoResize(int x, int y, int width, int height);
+extern void APIENTRY glutVideoPan(int x, int y, int width, int height);
+
+/* GLUT debugging sub-API. */
+extern void APIENTRY glutReportErrors(void);
+#endif
+
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
+/* GLUT device control sub-API. */
+/* glutSetKeyRepeat modes. */
+#define GLUT_KEY_REPEAT_OFF     0
+#define GLUT_KEY_REPEAT_ON      1
+#define GLUT_KEY_REPEAT_DEFAULT     2
+
+/* Joystick button masks. */
+#define GLUT_JOYSTICK_BUTTON_A      1
+#define GLUT_JOYSTICK_BUTTON_B      2
+#define GLUT_JOYSTICK_BUTTON_C      4
+#define GLUT_JOYSTICK_BUTTON_D      8
+
+extern void APIENTRY glutIgnoreKeyRepeat(int ignore);
+extern void APIENTRY glutSetKeyRepeat(int repeatMode);
+extern void APIENTRY glutForceJoystickFunc(void);
+
+/* GLUT game mode sub-API. */
+/* glutGameModeGet. */
+#define GLUT_GAME_MODE_ACTIVE           0
+#define GLUT_GAME_MODE_POSSIBLE         1
+#define GLUT_GAME_MODE_WIDTH            2
+#define GLUT_GAME_MODE_HEIGHT           3
+#define GLUT_GAME_MODE_PIXEL_DEPTH      4
+#define GLUT_GAME_MODE_REFRESH_RATE     5
+#define GLUT_GAME_MODE_DISPLAY_CHANGED  6
+
+extern void APIENTRY glutGameModeString(const char *string);
+extern int APIENTRY glutEnterGameMode(void);
+extern void APIENTRY glutLeaveGameMode(void);
+extern int APIENTRY glutGameModeGet(GLenum mode);
+#endif
+
+#ifdef __cplusplus
+}
+
+#endif
+
+#ifdef GLUT_APIENTRY_DEFINED
+# undef GLUT_APIENTRY_DEFINED
+# undef APIENTRY
+#endif
+
+#ifdef GLUT_WINGDIAPI_DEFINED
+# undef GLUT_WINGDIAPI_DEFINED
+# undef WINGDIAPI
+#endif
+
+#endif                  /* __glut_h__ */

Common/GL/glxext.h

@@ -0,0 +1,805 @@
+#ifndef __glxext_h_
+#define __glxext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2004 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+#ifndef GLAPI
+#define GLAPI extern
+#endif
+
+/*************************************************************/
+
+/* Header file version number, required by OpenGL ABI for Linux */
+/* glxext.h last updated 2005/01/20 */
+/* Current version at http://oss.sgi.com/projects/ogl-sample/registry/ */
+#define GLX_GLXEXT_VERSION 10
+
+#ifndef GLX_ARB_get_proc_address
+#endif
+
+#ifndef GLX_ARB_multisample
+#define GLX_SAMPLE_BUFFERS_ARB             100000
+#define GLX_SAMPLES_ARB                    100001
+#endif
+
+#ifndef GLX_ARB_fbconfig_float
+#define GLX_RGBA_FLOAT_TYPE_ARB            0x20B9
+#define GLX_RGBA_FLOAT_BIT_ARB             0x00000004
+#endif
+
+#ifndef GLX_SGIS_multisample
+#define GLX_SAMPLE_BUFFERS_SGIS            100000
+#define GLX_SAMPLES_SGIS                   100001
+#endif
+
+#ifndef GLX_EXT_visual_info
+#define GLX_X_VISUAL_TYPE_EXT              0x22
+#define GLX_TRANSPARENT_TYPE_EXT           0x23
+#define GLX_TRANSPARENT_INDEX_VALUE_EXT    0x24
+#define GLX_TRANSPARENT_RED_VALUE_EXT      0x25
+#define GLX_TRANSPARENT_GREEN_VALUE_EXT    0x26
+#define GLX_TRANSPARENT_BLUE_VALUE_EXT     0x27
+#define GLX_TRANSPARENT_ALPHA_VALUE_EXT    0x28
+#define GLX_NONE_EXT                       0x8000
+#define GLX_TRUE_COLOR_EXT                 0x8002
+#define GLX_DIRECT_COLOR_EXT               0x8003
+#define GLX_PSEUDO_COLOR_EXT               0x8004
+#define GLX_STATIC_COLOR_EXT               0x8005
+#define GLX_GRAY_SCALE_EXT                 0x8006
+#define GLX_STATIC_GRAY_EXT                0x8007
+#define GLX_TRANSPARENT_RGB_EXT            0x8008
+#define GLX_TRANSPARENT_INDEX_EXT          0x8009
+#endif
+
+#ifndef GLX_SGI_swap_control
+#endif
+
+#ifndef GLX_SGI_video_sync
+#endif
+
+#ifndef GLX_SGI_make_current_read
+#endif
+
+#ifndef GLX_SGIX_video_source
+#endif
+
+#ifndef GLX_EXT_visual_rating
+#define GLX_VISUAL_CAVEAT_EXT              0x20
+#define GLX_SLOW_VISUAL_EXT                0x8001
+#define GLX_NON_CONFORMANT_VISUAL_EXT      0x800D
+/* reuse GLX_NONE_EXT */
+#endif
+
+#ifndef GLX_EXT_import_context
+#define GLX_SHARE_CONTEXT_EXT              0x800A
+#define GLX_VISUAL_ID_EXT                  0x800B
+#define GLX_SCREEN_EXT                     0x800C
+#endif
+
+#ifndef GLX_SGIX_fbconfig
+#define GLX_WINDOW_BIT_SGIX                0x00000001
+#define GLX_PIXMAP_BIT_SGIX                0x00000002
+#define GLX_RGBA_BIT_SGIX                  0x00000001
+#define GLX_COLOR_INDEX_BIT_SGIX           0x00000002
+#define GLX_DRAWABLE_TYPE_SGIX             0x8010
+#define GLX_RENDER_TYPE_SGIX               0x8011
+#define GLX_X_RENDERABLE_SGIX              0x8012
+#define GLX_FBCONFIG_ID_SGIX               0x8013
+#define GLX_RGBA_TYPE_SGIX                 0x8014
+#define GLX_COLOR_INDEX_TYPE_SGIX          0x8015
+/* reuse GLX_SCREEN_EXT */
+#endif
+
+#ifndef GLX_SGIX_pbuffer
+#define GLX_PBUFFER_BIT_SGIX               0x00000004
+#define GLX_BUFFER_CLOBBER_MASK_SGIX       0x08000000
+#define GLX_FRONT_LEFT_BUFFER_BIT_SGIX     0x00000001
+#define GLX_FRONT_RIGHT_BUFFER_BIT_SGIX    0x00000002
+#define GLX_BACK_LEFT_BUFFER_BIT_SGIX      0x00000004
+#define GLX_BACK_RIGHT_BUFFER_BIT_SGIX     0x00000008
+#define GLX_AUX_BUFFERS_BIT_SGIX           0x00000010
+#define GLX_DEPTH_BUFFER_BIT_SGIX          0x00000020
+#define GLX_STENCIL_BUFFER_BIT_SGIX        0x00000040
+#define GLX_ACCUM_BUFFER_BIT_SGIX          0x00000080
+#define GLX_SAMPLE_BUFFERS_BIT_SGIX        0x00000100
+#define GLX_MAX_PBUFFER_WIDTH_SGIX         0x8016
+#define GLX_MAX_PBUFFER_HEIGHT_SGIX        0x8017
+#define GLX_MAX_PBUFFER_PIXELS_SGIX        0x8018
+#define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX     0x8019
+#define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX    0x801A
+#define GLX_PRESERVED_CONTENTS_SGIX        0x801B
+#define GLX_LARGEST_PBUFFER_SGIX           0x801C
+#define GLX_WIDTH_SGIX                     0x801D
+#define GLX_HEIGHT_SGIX                    0x801E
+#define GLX_EVENT_MASK_SGIX                0x801F
+#define GLX_DAMAGED_SGIX                   0x8020
+#define GLX_SAVED_SGIX                     0x8021
+#define GLX_WINDOW_SGIX                    0x8022
+#define GLX_PBUFFER_SGIX                   0x8023
+#endif
+
+#ifndef GLX_SGI_cushion
+#endif
+
+#ifndef GLX_SGIX_video_resize
+#define GLX_SYNC_FRAME_SGIX                0x00000000
+#define GLX_SYNC_SWAP_SGIX                 0x00000001
+#endif
+
+#ifndef GLX_SGIX_dmbuffer
+#define GLX_DIGITAL_MEDIA_PBUFFER_SGIX     0x8024
+#endif
+
+#ifndef GLX_SGIX_swap_group
+#endif
+
+#ifndef GLX_SGIX_swap_barrier
+#endif
+
+#ifndef GLX_SGIS_blended_overlay
+#define GLX_BLENDED_RGBA_SGIS              0x8025
+#endif
+
+#ifndef GLX_SGIS_shared_multisample
+#define GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS 0x8026
+#define GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS 0x8027
+#endif
+
+#ifndef GLX_SUN_get_transparent_index
+#endif
+
+#ifndef GLX_3DFX_multisample
+#define GLX_SAMPLE_BUFFERS_3DFX            0x8050
+#define GLX_SAMPLES_3DFX                   0x8051
+#endif
+
+#ifndef GLX_MESA_copy_sub_buffer
+#endif
+
+#ifndef GLX_MESA_pixmap_colormap
+#endif
+
+#ifndef GLX_MESA_release_buffers
+#endif
+
+#ifndef GLX_MESA_set_3dfx_mode
+#define GLX_3DFX_WINDOW_MODE_MESA          0x1
+#define GLX_3DFX_FULLSCREEN_MODE_MESA      0x2
+#endif
+
+#ifndef GLX_SGIX_visual_select_group
+#define GLX_VISUAL_SELECT_GROUP_SGIX       0x8028
+#endif
+
+#ifndef GLX_OML_swap_method
+#define GLX_SWAP_METHOD_OML                0x8060
+#define GLX_SWAP_EXCHANGE_OML              0x8061
+#define GLX_SWAP_COPY_OML                  0x8062
+#define GLX_SWAP_UNDEFINED_OML             0x8063
+#endif
+
+#ifndef GLX_OML_sync_control
+#endif
+
+#ifndef GLX_NV_float_buffer
+#define GLX_FLOAT_COMPONENTS_NV            0x20B0
+#endif
+
+#ifndef GLX_SGIX_hyperpipe
+#define GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX 80
+#define GLX_BAD_HYPERPIPE_CONFIG_SGIX      91
+#define GLX_BAD_HYPERPIPE_SGIX             92
+#define GLX_HYPERPIPE_DISPLAY_PIPE_SGIX    0x00000001
+#define GLX_HYPERPIPE_RENDER_PIPE_SGIX     0x00000002
+#define GLX_PIPE_RECT_SGIX                 0x00000001
+#define GLX_PIPE_RECT_LIMITS_SGIX          0x00000002
+#define GLX_HYPERPIPE_STEREO_SGIX          0x00000003
+#define GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX   0x00000004
+#define GLX_HYPERPIPE_ID_SGIX              0x8030
+#endif
+
+#ifndef GLX_MESA_agp_offset
+#endif
+
+
+/*************************************************************/
+
+#ifndef GLX_ARB_get_proc_address
+/*
+ * Linux OpenGL ABI specifies glXGetProcAddressARB should be
+ * in glx.h moving related defines there as well.
+ */
+#endif
+
+#ifndef GLX_SGIX_video_source
+typedef XID GLXVideoSourceSGIX;
+#endif
+
+#ifndef GLX_SGIX_fbconfig
+typedef XID GLXFBConfigIDSGIX;
+typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
+#endif
+
+#ifndef GLX_SGIX_pbuffer
+typedef XID GLXPbufferSGIX;
+typedef struct
+{
+    int type;
+    unsigned long serial;     /* # of last request processed by server */
+    Bool send_event;          /* true if this came for SendEvent request */
+    Display *display;         /* display the event was read from */
+    GLXDrawable drawable;     /* i.d. of Drawable */
+    int event_type;       /* GLX_DAMAGED_SGIX or GLX_SAVED_SGIX */
+    int draw_type;        /* GLX_WINDOW_SGIX or GLX_PBUFFER_SGIX */
+    unsigned int mask;    /* mask indicating which buffers are affected*/
+    int x, y;
+    int width, height;
+    int count;        /* if nonzero, at least this many more */
+} GLXBufferClobberEventSGIX;
+#endif
+
+#ifndef GLX_NV_swap_group
+#endif
+
+#ifndef GLX_NV_video_out
+/*
+ * GLXVideoDeviceNV is an opaque handle to a video device (part of the
+ * GLX_NV_video_out extension).
+ */
+typedef unsigned int GLXVideoDeviceNV;
+
+/* glXBindVideoImageNV iVideoBuffer values (NV_video_out) */
+#define GLX_VIDEO_OUT_COLOR_NV           0x20C3
+#define GLX_VIDEO_OUT_ALPHA_NV           0x20C4
+#define GLX_VIDEO_OUT_DEPTH_NV           0x20C5
+#define GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6
+#define GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7
+
+/* glXSendPbufferToVideoNV iBufferType values (NV_video_out) */
+#define GLX_VIDEO_OUT_FRAME_NV           0x20C8
+#define GLX_VIDEO_OUT_FIELD_1_NV         0x20C9
+#define GLX_VIDEO_OUT_FIELD_2_NV         0x20CA
+#endif
+
+#ifndef GLX_EXT_texture_from_pixmap
+/* New glXGetFBConfigAttrib <attrib_list> tokens */
+#define GLX_BIND_TO_TEXTURE_RGB_EXT      0x20D0
+#define GLX_BIND_TO_TEXTURE_RGBA_EXT     0x20D1
+#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT   0x20D2
+#define GLX_BIND_TO_TEXTURE_TARGETS_EXT  0x20D3
+#define GLX_Y_INVERTED_EXT               0x20D4
+
+/* New glXCreatePixmap attributes and glXQueryDrawable attributes */
+#define GLX_TEXTURE_FORMAT_EXT           0x20D5
+#define GLX_TEXTURE_TARGET_EXT           0x20D6
+#define GLX_MIPMAP_TEXTURE_EXT           0x20D7
+
+/* Values for GLX_TEXTURE_FORMAT_EXT */
+#define GLX_TEXTURE_FORMAT_NONE_EXT      0x20D8
+#define GLX_TEXTURE_FORMAT_RGB_EXT       0x20D9
+#define GLX_TEXTURE_FORMAT_RGBA_EXT      0x20DA
+
+/* Bits for GLX_BIND_TO_TEXTURE_TARGETS_EXT mask */
+#define GLX_TEXTURE_1D_BIT_EXT           0x00000001
+#define GLX_TEXTURE_2D_BIT_EXT           0x00000002
+#define GLX_TEXTURE_RECTANGLE_BIT_EXT    0x00000004
+
+/* Values for GLX_TEXTURE_TARGET_EXT */
+#define GLX_TEXTURE_1D_EXT               0x20DB
+#define GLX_TEXTURE_2D_EXT               0x20DC
+#define GLX_TEXTURE_RECTANGLE_EXT        0x20DD
+
+/*
+ * Values for the buffer parameter of glXBindTexImageEXT and
+ * glXReleaseTexImageEXT
+ */
+#define GLX_FRONT_LEFT_EXT               0x20DE
+#define GLX_FRONT_RIGHT_EXT              0x20DF
+#define GLX_BACK_LEFT_EXT                0x20E0
+#define GLX_BACK_RIGHT_EXT               0x20E1
+#define GLX_FRONT_EXT                    GLX_FRONT_LEFT_EXT
+#define GLX_BACK_EXT                     GLX_BACK_LEFT_EXT
+#define GLX_AUX0_EXT                     0x20E2
+#define GLX_AUX1_EXT                     0x20E3
+#define GLX_AUX2_EXT                     0x20E4
+#define GLX_AUX3_EXT                     0x20E5
+#define GLX_AUX4_EXT                     0x20E6
+#define GLX_AUX5_EXT                     0x20E7
+#define GLX_AUX6_EXT                     0x20E8
+#define GLX_AUX7_EXT                     0x20E9
+#define GLX_AUX8_EXT                     0x20EA
+#define GLX_AUX9_EXT                     0x20EB
+
+#endif
+
+/* Define int32_t and int64_t types for UST/MSC */
+/* (as used in the GLX_OML_sync_control extension). */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#elif defined( __VMS ) || defined(__FreeBSD__)
+#include <inttypes.h>
+#elif (defined(__sun__) && defined(__svr4__)) || (defined(__sun) && defined(__SVR4))
+#include <inttypes.h>
+#elif defined(__SCO__) || defined(__USLC__) || defined(__linux__)
+#include <stdint.h>
+#elif defined(__UNIXOS2__) || defined(__SOL64__)
+typedef long int int32_t;
+typedef long long int int64_t;
+#else
+#error "int32_t and int64_t are undefined!"
+#endif
+
+#ifndef GLX_ARB_get_proc_address
+/* Moved to glx.h */
+#endif
+
+#ifndef GLX_ARB_multisample
+#define GLX_ARB_multisample 1
+#endif
+
+#ifndef GLX_ARB_fbconfig_float
+#define GLX_ARB_fbconfig_float 1
+#endif
+
+#ifndef GLX_SGIS_multisample
+#define GLX_SGIS_multisample 1
+#endif
+
+#ifndef GLX_EXT_visual_info
+#define GLX_EXT_visual_info 1
+#endif
+
+#ifndef GLX_SGI_swap_control
+#define GLX_SGI_swap_control 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXSwapIntervalSGI(int);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int (* PFNGLXSWAPINTERVALSGIPROC)(int interval);
+#endif
+
+#ifndef GLX_SGI_video_sync
+#define GLX_SGI_video_sync 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXGetVideoSyncSGI(unsigned int *);
+extern int glXWaitVideoSyncSGI(int, int, unsigned int *);
+extern int glXGetRefreshRateSGI(unsigned int *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int (* PFNGLXGETVIDEOSYNCSGIPROC)(unsigned int *count);
+typedef int (* PFNGLXWAITVIDEOSYNCSGIPROC)(int divisor, int remainder, unsigned int *count);
+typedef int (* PFNGLXGETREFRESHRATESGIPROC)(unsigned int *);
+#endif
+
+#ifndef GLX_SGI_make_current_read
+#define GLX_SGI_make_current_read 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXMakeCurrentReadSGI(Display *, GLXDrawable, GLXDrawable, GLXContext);
+extern GLXDrawable glXGetCurrentReadDrawableSGI(void);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool(* PFNGLXMAKECURRENTREADSGIPROC)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+typedef GLXDrawable(* PFNGLXGETCURRENTREADDRAWABLESGIPROC)(void);
+#endif
+
+#ifndef GLX_SGIX_video_source
+#define GLX_SGIX_video_source 1
+#ifdef _VL_H
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXVideoSourceSGIX glXCreateGLXVideoSourceSGIX(Display *, int, VLServer, VLPath, int, VLNode);
+extern void glXDestroyGLXVideoSourceSGIX(Display *, GLXVideoSourceSGIX);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXVideoSourceSGIX(* PFNGLXCREATEGLXVIDEOSOURCESGIXPROC)(Display *display, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode);
+typedef void (* PFNGLXDESTROYGLXVIDEOSOURCESGIXPROC)(Display *dpy, GLXVideoSourceSGIX glxvideosource);
+#endif /* _VL_H */
+#endif
+
+#ifndef GLX_EXT_visual_rating
+#define GLX_EXT_visual_rating 1
+#endif
+
+#ifndef GLX_EXT_import_context
+#define GLX_EXT_import_context 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Display *glXGetCurrentDisplayEXT(void);
+extern int glXQueryContextInfoEXT(Display *, GLXContext, int, int *);
+extern GLXContextID glXGetContextIDEXT(const GLXContext);
+extern GLXContext glXImportContextEXT(Display *, GLXContextID);
+extern void glXFreeContextEXT(Display *, GLXContext);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Display *(* PFNGLXGETCURRENTDISPLAYEXTPROC)(void);
+typedef int (* PFNGLXQUERYCONTEXTINFOEXTPROC)(Display *dpy, GLXContext context, int attribute, int *value);
+typedef GLXContextID(* PFNGLXGETCONTEXTIDEXTPROC)(const GLXContext context);
+typedef GLXContext(* PFNGLXIMPORTCONTEXTEXTPROC)(Display *dpy, GLXContextID contextID);
+typedef void (* PFNGLXFREECONTEXTEXTPROC)(Display *dpy, GLXContext context);
+#endif
+
+#ifndef GLX_SGIX_fbconfig
+#define GLX_SGIX_fbconfig 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXGetFBConfigAttribSGIX(Display *, GLXFBConfigSGIX, int, int *);
+extern GLXFBConfigSGIX *glXChooseFBConfigSGIX(Display *, int, int *, int *);
+extern GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *, GLXFBConfigSGIX, Pixmap);
+extern GLXContext glXCreateContextWithConfigSGIX(Display *, GLXFBConfigSGIX, int, GLXContext, Bool);
+extern XVisualInfo *glXGetVisualFromFBConfigSGIX(Display *, GLXFBConfigSGIX);
+extern GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *, XVisualInfo *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int (* PFNGLXGETFBCONFIGATTRIBSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
+typedef GLXFBConfigSGIX *(* PFNGLXCHOOSEFBCONFIGSGIXPROC)(Display *dpy, int screen, int *attrib_list, int *nelements);
+typedef GLXPixmap(* PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap);
+typedef GLXContext(* PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
+typedef XVisualInfo *(* PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config);
+typedef GLXFBConfigSGIX(* PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)(Display *dpy, XVisualInfo *vis);
+#endif
+
+#ifndef GLX_SGIX_pbuffer
+#define GLX_SGIX_pbuffer 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXPbufferSGIX glXCreateGLXPbufferSGIX(Display *, GLXFBConfigSGIX, unsigned int, unsigned int, int *);
+extern void glXDestroyGLXPbufferSGIX(Display *, GLXPbufferSGIX);
+extern int glXQueryGLXPbufferSGIX(Display *, GLXPbufferSGIX, int, unsigned int *);
+extern void glXSelectEventSGIX(Display *, GLXDrawable, unsigned long);
+extern void glXGetSelectedEventSGIX(Display *, GLXDrawable, unsigned long *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXPbufferSGIX(* PFNGLXCREATEGLXPBUFFERSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list);
+typedef void (* PFNGLXDESTROYGLXPBUFFERSGIXPROC)(Display *dpy, GLXPbufferSGIX pbuf);
+typedef int (* PFNGLXQUERYGLXPBUFFERSGIXPROC)(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value);
+typedef void (* PFNGLXSELECTEVENTSGIXPROC)(Display *dpy, GLXDrawable drawable, unsigned long mask);
+typedef void (* PFNGLXGETSELECTEDEVENTSGIXPROC)(Display *dpy, GLXDrawable drawable, unsigned long *mask);
+#endif
+
+#ifndef GLX_SGI_cushion
+#define GLX_SGI_cushion 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXCushionSGI(Display *, Window, float);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void (* PFNGLXCUSHIONSGIPROC)(Display *dpy, Window window, float cushion);
+#endif
+
+#ifndef GLX_SGIX_video_resize
+#define GLX_SGIX_video_resize 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXBindChannelToWindowSGIX(Display *, int, int, Window);
+extern int glXChannelRectSGIX(Display *, int, int, int, int, int, int);
+extern int glXQueryChannelRectSGIX(Display *, int, int, int *, int *, int *, int *);
+extern int glXQueryChannelDeltasSGIX(Display *, int, int, int *, int *, int *, int *);
+extern int glXChannelRectSyncSGIX(Display *, int, int, GLenum);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int (* PFNGLXBINDCHANNELTOWINDOWSGIXPROC)(Display *display, int screen, int channel, Window window);
+typedef int (* PFNGLXCHANNELRECTSGIXPROC)(Display *display, int screen, int channel, int x, int y, int w, int h);
+typedef int (* PFNGLXQUERYCHANNELRECTSGIXPROC)(Display *display, int screen, int channel, int *dx, int *dy, int *dw, int *dh);
+typedef int (* PFNGLXQUERYCHANNELDELTASSGIXPROC)(Display *display, int screen, int channel, int *x, int *y, int *w, int *h);
+typedef int (* PFNGLXCHANNELRECTSYNCSGIXPROC)(Display *display, int screen, int channel, GLenum synctype);
+#endif
+
+#ifndef GLX_SGIX_dmbuffer
+#define GLX_SGIX_dmbuffer 1
+#ifdef _DM_BUFFER_H_
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXAssociateDMPbufferSGIX(Display *, GLXPbufferSGIX, DMparams *, DMbuffer);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool(* PFNGLXASSOCIATEDMPBUFFERSGIXPROC)(Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer);
+#endif /* _DM_BUFFER_H_ */
+#endif
+
+#ifndef GLX_SGIX_swap_group
+#define GLX_SGIX_swap_group 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXJoinSwapGroupSGIX(Display *, GLXDrawable, GLXDrawable);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void (* PFNGLXJOINSWAPGROUPSGIXPROC)(Display *dpy, GLXDrawable drawable, GLXDrawable member);
+#endif
+
+#ifndef GLX_SGIX_swap_barrier
+#define GLX_SGIX_swap_barrier 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXBindSwapBarrierSGIX(Display *, GLXDrawable, int);
+extern Bool glXQueryMaxSwapBarriersSGIX(Display *, int, int *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void (* PFNGLXBINDSWAPBARRIERSGIXPROC)(Display *dpy, GLXDrawable drawable, int barrier);
+typedef Bool(* PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)(Display *dpy, int screen, int *max);
+#endif
+
+#ifndef GLX_SUN_get_transparent_index
+#define GLX_SUN_get_transparent_index 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Status glXGetTransparentIndexSUN(Display *, Window, Window, long *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Status(* PFNGLXGETTRANSPARENTINDEXSUNPROC)(Display *dpy, Window overlay, Window underlay, long *pTransparentIndex);
+#endif
+
+#ifndef GLX_MESA_copy_sub_buffer
+#define GLX_MESA_copy_sub_buffer 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXCopySubBufferMESA(Display *, GLXDrawable, int, int, int, int);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void (* PFNGLXCOPYSUBBUFFERMESAPROC)(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
+#endif
+
+#ifndef GLX_MESA_pixmap_colormap
+#define GLX_MESA_pixmap_colormap 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXPixmap glXCreateGLXPixmapMESA(Display *, XVisualInfo *, Pixmap, Colormap);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXPixmap(* PFNGLXCREATEGLXPIXMAPMESAPROC)(Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap);
+#endif
+
+#ifndef GLX_MESA_release_buffers
+#define GLX_MESA_release_buffers 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXReleaseBuffersMESA(Display *, GLXDrawable);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool(* PFNGLXRELEASEBUFFERSMESAPROC)(Display *dpy, GLXDrawable drawable);
+#endif
+
+#ifndef GLX_MESA_set_3dfx_mode
+#define GLX_MESA_set_3dfx_mode 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXSet3DfxModeMESA(int);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool(* PFNGLXSET3DFXMODEMESAPROC)(int mode);
+#endif
+
+#ifndef GLX_SGIX_visual_select_group
+#define GLX_SGIX_visual_select_group 1
+#endif
+
+#ifndef GLX_OML_swap_method
+#define GLX_OML_swap_method 1
+#endif
+
+#ifndef GLX_OML_sync_control
+#define GLX_OML_sync_control 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXGetSyncValuesOML(Display *, GLXDrawable, int64_t *, int64_t *, int64_t *);
+extern Bool glXGetMscRateOML(Display *, GLXDrawable, int32_t *, int32_t *);
+extern int64_t glXSwapBuffersMscOML(Display *, GLXDrawable, int64_t, int64_t, int64_t);
+extern Bool glXWaitForMscOML(Display *, GLXDrawable, int64_t, int64_t, int64_t, int64_t *, int64_t *, int64_t *);
+extern Bool glXWaitForSbcOML(Display *, GLXDrawable, int64_t, int64_t *, int64_t *, int64_t *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool(* PFNGLXGETSYNCVALUESOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
+typedef Bool(* PFNGLXGETMSCRATEOMLPROC)(Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
+typedef int64_t (* PFNGLXSWAPBUFFERSMSCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
+typedef Bool(* PFNGLXWAITFORMSCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc);
+typedef Bool(* PFNGLXWAITFORSBCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
+#endif
+
+#ifndef GLX_NV_float_buffer
+#define GLX_NV_float_buffer 1
+#endif
+
+#ifndef GLX_SGIX_hyperpipe
+#define GLX_SGIX_hyperpipe 1
+
+typedef struct
+{
+    char    pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+    int     networkId;
+} GLXHyperpipeNetworkSGIX;
+
+typedef struct
+{
+    char    pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+    int     channel;
+    unsigned int
+    participationType;
+    int     timeSlice;
+} GLXHyperpipeConfigSGIX;
+
+typedef struct
+{
+    char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+    int srcXOrigin, srcYOrigin, srcWidth, srcHeight;
+    int destXOrigin, destYOrigin, destWidth, destHeight;
+} GLXPipeRect;
+
+typedef struct
+{
+    char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+    int XOrigin, YOrigin, maxHeight, maxWidth;
+} GLXPipeRectLimits;
+
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXHyperpipeNetworkSGIX *glXQueryHyperpipeNetworkSGIX(Display *, int *);
+extern int glXHyperpipeConfigSGIX(Display *, int, int, GLXHyperpipeConfigSGIX *, int *);
+extern GLXHyperpipeConfigSGIX *glXQueryHyperpipeConfigSGIX(Display *, int, int *);
+extern int glXDestroyHyperpipeConfigSGIX(Display *, int);
+extern int glXBindHyperpipeSGIX(Display *, int);
+extern int glXQueryHyperpipeBestAttribSGIX(Display *, int, int, int, void *, void *);
+extern int glXHyperpipeAttribSGIX(Display *, int, int, int, void *);
+extern int glXQueryHyperpipeAttribSGIX(Display *, int, int, int, void *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXHyperpipeNetworkSGIX *(* PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)(Display *dpy, int *npipes);
+typedef int (* PFNGLXHYPERPIPECONFIGSGIXPROC)(Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX *cfg, int *hpId);
+typedef GLXHyperpipeConfigSGIX *(* PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)(Display *dpy, int hpId, int *npipes);
+typedef int (* PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)(Display *dpy, int hpId);
+typedef int (* PFNGLXBINDHYPERPIPESGIXPROC)(Display *dpy, int hpId);
+typedef int (* PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *attribList, void *returnAttribList);
+typedef int (* PFNGLXHYPERPIPEATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *attribList);
+typedef int (* PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *returnAttribList);
+#endif
+
+#ifndef GLX_MESA_agp_offset
+#define GLX_MESA_agp_offset 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern unsigned int glXGetAGPOffsetMESA(const void *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef unsigned int (* PFNGLXGETAGPOFFSETMESAPROC)(const void *pointer);
+#endif
+
+/*
+ * GLX_NV_vertex_array_range is not a real extension name...
+ */
+#ifndef GLX_NV_vertex_array_range
+#define GLX_NV_vertex_array_range 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void *glXAllocateMemoryNV(GLsizei size, GLfloat readfreq,
+                                 GLfloat writefreq, GLfloat priority);
+
+extern void glXFreeMemoryNV(GLvoid *pointer);
+#endif
+typedef void *(* PFNGLXALLOCATEMEMORYNVPROC)(GLsizei size,
+                                             GLfloat readfreq,
+                                             GLfloat writefreq,
+                                             GLfloat priority);
+
+typedef void (* PFNGLXFREEMEMORYNVPROC)(GLvoid *pointer);
+#endif
+
+#ifndef GLX_NV_swap_group
+#define GLX_NV_swap_group 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXJoinSwapGroupNV(Display *dpy, GLXDrawable drawable,
+                               GLuint group);
+
+extern Bool glXBindSwapBarrierNV(Display *dpy, GLuint group, GLuint barrier);
+
+extern Bool glXQuerySwapGroupNV(Display *dpy, GLXDrawable drawable,
+                                GLuint *group, GLuint *barrier);
+
+extern Bool glXQueryMaxSwapGroupsNV(Display *dpy, int screen,
+                                    GLuint *maxGroups, GLuint *maxBarriers);
+
+extern Bool glXQueryFrameCountNV(Display *dpy, int screen, GLuint *count);
+
+extern Bool glXResetFrameCountNV(Display *dpy, int screen);
+#endif
+typedef Bool(* PFNGLXJOINSWAPGROUPNVPROC)(Display *dpy,
+                                          GLXDrawable drawable,
+                                          GLuint group);
+
+typedef Bool(* PFNGLXBINDSWAPBARRIERNVPROC)(Display *dpy,
+                                            GLuint group,
+                                            GLuint barrier);
+
+typedef Bool(* PFNGLXQUERYSWAPGROUPNVPROC)(Display *dpy,
+                                           GLXDrawable drawable,
+                                           GLuint *group,
+                                           GLuint *barrier);
+
+typedef Bool(* PFNGLXQUERYMAXSWAPGROUPSNVPROC)(Display *dpy,
+                                               int screen,
+                                               GLuint *maxGroups,
+                                               GLuint *maxBarriers);
+
+typedef Bool(* PFNGLXQUERYFRAMECOUNTNVPROC)(Display *dpy,
+                                            int screen,
+                                            GLuint *count);
+
+typedef Bool(* PFNGLXRESETFRAMECOUNTNVPROC)(Display *dpy, int screen);
+#endif
+
+#ifndef GLX_NV_video_out
+#define GLX_NV_video_out 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXGetVideoDeviceNV(Display *dpy, int screen, int numVideoDevices,
+                               GLXVideoDeviceNV *pVideoDevice);
+
+extern int glXReleaseVideoDeviceNV(Display *dpy, int screen,
+                                   GLXVideoDeviceNV VideoDevice);
+
+extern int glXBindVideoImageNV(Display *dpy, GLXVideoDeviceNV VideoDevice,
+                               GLXPbuffer pbuf, int iVideoBuffer);
+
+extern int glXReleaseVideoImageNV(Display *dpy, GLXPbuffer pbuf);
+
+extern int glXSendPbufferToVideoNV(Display *dpy, GLXPbuffer pbuf,
+                                   int iBufferType,
+                                   unsigned long *pulCounterPbuffer,
+                                   GLboolean bBlock);
+
+extern int glXGetVideoInfoNV(Display *dpy, int screen,
+                             GLXVideoDeviceNV VideoDevice,
+                             unsigned long *pulCounterOutputVideo,
+                             unsigned long *pulCounterOutputPbuffer);
+#endif
+typedef int (* PFNGLXGETVIDEODEVICENVPROC)(Display *dpy,
+                                           int screen,
+                                           int numVideoDevices,
+                                           GLXVideoDeviceNV *pVideoDevice);
+
+typedef int (* PFNGLXRELEASEVIDEODEVICENVPROC)(Display *dpy,
+                                               int screen,
+                                               GLXVideoDeviceNV VideoDevice);
+
+typedef int (* PFNGLXBINDVIDEOIMAGENVPROC)(Display *dpy,
+                                           GLXVideoDeviceNV VideoDevice,
+                                           GLXPbuffer pbuf,
+                                           int iVideoBuffer);
+
+typedef int (* PFNGLXRELEASEVIDEOIMAGENVPROC)(Display *dpy,
+                                              GLXPbuffer pbuf);
+
+typedef int (* PFNGLXSENDPBUFFERTOVIDEONVPROC)(Display *dpy,
+                                               GLXPbuffer pbuf,
+                                               int iBufferType,
+                                               unsigned long *pulCounterPbuffer,
+                                               GLboolean bBlock);
+
+typedef int (* PFNGLXGETVIDEOINFONVPROC)(Display *dpy, int screen,
+                                         GLXVideoDeviceNV VideoDevice,
+                                         unsigned long *pulCounterOutputVideo,
+                                         unsigned long *pulCounterOutputPbuffer);
+#endif
+
+#ifndef GLX_EXT_texture_from_pixmap
+#define GLX_EXT_texture_from_pixmap
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXBindTexImageEXT(Display *dpy, GLXDrawable drawable,
+                               int buffer, const int *attrib_list);
+extern void glXReleaseTexImageEXT(Display *dpy, GLXDrawable drawable,
+                                  int buffer);
+#endif
+typedef void (* PFNGLXBINDTEXIMAGEEXTPROC)(Display *dpy,
+                                           GLXDrawable drawable,
+                                           int buffer,
+                                           const int *attrib_list);
+typedef void (* PFNGLXRELEASETEXIMAGEEXTPROC)(Display *dpy,
+                                              GLXDrawable drawable,
+                                              int buffer);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Common/GL/wglew.h

@@ -0,0 +1,958 @@
+/*
+** The OpenGL Extension Wrangler Library
+** Copyright (C) 2002-2006, Milan Ikits <milan ikits[]ieee org>
+** Copyright (C) 2002-2006, Marcelo E. Magallon <mmagallo[]debian org>
+** Copyright (C) 2002, Lev Povalahev
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are met:
+**
+** * Redistributions of source code must retain the above copyright notice,
+**   this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright notice,
+**   this list of conditions and the following disclaimer in the documentation
+**   and/or other materials provided with the distribution.
+** * The name of the author may be used to endorse or promote products
+**   derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+** THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef __wglew_h__
+#define __wglew_h__
+#define __WGLEW_H__
+
+#ifdef __wglext_h_
+#error wglext.h included before wglew.h
+#endif
+
+#define __wglext_h_
+
+#if !defined(APIENTRY) && !defined(__CYGWIN__)
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN 1
+#  endif
+#include <windows.h>
+#endif
+
+/*
+ * GLEW_STATIC needs to be set when using the static version.
+ * GLEW_BUILD is set when building the DLL version.
+ */
+#ifdef GLEW_STATIC
+#  define GLEWAPI extern
+#else
+#  ifdef GLEW_BUILD
+#    define GLEWAPI extern __declspec(dllexport)
+#  else
+#    define GLEWAPI extern __declspec(dllimport)
+#  endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* -------------------------- WGL_3DFX_multisample ------------------------- */
+
+#ifndef WGL_3DFX_multisample
+#define WGL_3DFX_multisample 1
+
+#define WGL_SAMPLE_BUFFERS_3DFX 0x2060
+#define WGL_SAMPLES_3DFX 0x2061
+
+#define WGLEW_3DFX_multisample WGLEW_GET_VAR(__WGLEW_3DFX_multisample)
+
+#endif /* WGL_3DFX_multisample */
+
+/* ------------------------- WGL_3DL_stereo_control ------------------------ */
+
+#ifndef WGL_3DL_stereo_control
+#define WGL_3DL_stereo_control 1
+
+#define WGL_STEREO_EMITTER_ENABLE_3DL 0x2055
+#define WGL_STEREO_EMITTER_DISABLE_3DL 0x2056
+#define WGL_STEREO_POLARITY_NORMAL_3DL 0x2057
+#define WGL_STEREO_POLARITY_INVERT_3DL 0x2058
+
+typedef BOOL (WINAPI *PFNWGLSETSTEREOEMITTERSTATE3DLPROC)(HDC hDC, UINT uState);
+
+#define wglSetStereoEmitterState3DL WGLEW_GET_FUN(__wglewSetStereoEmitterState3DL)
+
+#define WGLEW_3DL_stereo_control WGLEW_GET_VAR(__WGLEW_3DL_stereo_control)
+
+#endif /* WGL_3DL_stereo_control */
+
+/* ------------------------- WGL_ARB_buffer_region ------------------------- */
+
+#ifndef WGL_ARB_buffer_region
+#define WGL_ARB_buffer_region 1
+
+#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
+#define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
+#define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
+#define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
+
+typedef HANDLE(WINAPI *PFNWGLCREATEBUFFERREGIONARBPROC)(HDC hDC, int iLayerPlane, UINT uType);
+typedef VOID (WINAPI *PFNWGLDELETEBUFFERREGIONARBPROC)(HANDLE hRegion);
+typedef BOOL (WINAPI *PFNWGLRESTOREBUFFERREGIONARBPROC)(HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
+typedef BOOL (WINAPI *PFNWGLSAVEBUFFERREGIONARBPROC)(HANDLE hRegion, int x, int y, int width, int height);
+
+#define wglCreateBufferRegionARB WGLEW_GET_FUN(__wglewCreateBufferRegionARB)
+#define wglDeleteBufferRegionARB WGLEW_GET_FUN(__wglewDeleteBufferRegionARB)
+#define wglRestoreBufferRegionARB WGLEW_GET_FUN(__wglewRestoreBufferRegionARB)
+#define wglSaveBufferRegionARB WGLEW_GET_FUN(__wglewSaveBufferRegionARB)
+
+#define WGLEW_ARB_buffer_region WGLEW_GET_VAR(__WGLEW_ARB_buffer_region)
+
+#endif /* WGL_ARB_buffer_region */
+
+/* ----------------------- WGL_ARB_extensions_string ----------------------- */
+
+#ifndef WGL_ARB_extensions_string
+#define WGL_ARB_extensions_string 1
+
+typedef const char *(WINAPI *PFNWGLGETEXTENSIONSSTRINGARBPROC)(HDC hdc);
+
+#define wglGetExtensionsStringARB WGLEW_GET_FUN(__wglewGetExtensionsStringARB)
+
+#define WGLEW_ARB_extensions_string WGLEW_GET_VAR(__WGLEW_ARB_extensions_string)
+
+#endif /* WGL_ARB_extensions_string */
+
+/* ----------------------- WGL_ARB_make_current_read ----------------------- */
+
+#ifndef WGL_ARB_make_current_read
+#define WGL_ARB_make_current_read 1
+
+typedef HDC(WINAPI *PFNWGLGETCURRENTREADDCARBPROC)(VOID);
+typedef BOOL (WINAPI *PFNWGLMAKECONTEXTCURRENTARBPROC)(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+
+#define wglGetCurrentReadDCARB WGLEW_GET_FUN(__wglewGetCurrentReadDCARB)
+#define wglMakeContextCurrentARB WGLEW_GET_FUN(__wglewMakeContextCurrentARB)
+
+#define WGLEW_ARB_make_current_read WGLEW_GET_VAR(__WGLEW_ARB_make_current_read)
+
+#endif /* WGL_ARB_make_current_read */
+
+/* -------------------------- WGL_ARB_multisample -------------------------- */
+
+#ifndef WGL_ARB_multisample
+#define WGL_ARB_multisample 1
+
+#define WGL_SAMPLE_BUFFERS_ARB 0x2041
+#define WGL_SAMPLES_ARB 0x2042
+
+#define WGLEW_ARB_multisample WGLEW_GET_VAR(__WGLEW_ARB_multisample)
+
+#endif /* WGL_ARB_multisample */
+
+/* ---------------------------- WGL_ARB_pbuffer ---------------------------- */
+
+#ifndef WGL_ARB_pbuffer
+#define WGL_ARB_pbuffer 1
+
+#define WGL_DRAW_TO_PBUFFER_ARB 0x202D
+#define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
+#define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
+#define WGL_PBUFFER_LARGEST_ARB 0x2033
+#define WGL_PBUFFER_WIDTH_ARB 0x2034
+#define WGL_PBUFFER_HEIGHT_ARB 0x2035
+#define WGL_PBUFFER_LOST_ARB 0x2036
+
+DECLARE_HANDLE(HPBUFFERARB);
+
+typedef HPBUFFERARB(WINAPI *PFNWGLCREATEPBUFFERARBPROC)(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef BOOL (WINAPI *PFNWGLDESTROYPBUFFERARBPROC)(HPBUFFERARB hPbuffer);
+typedef HDC(WINAPI *PFNWGLGETPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer);
+typedef BOOL (WINAPI *PFNWGLQUERYPBUFFERARBPROC)(HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
+typedef int (WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer, HDC hDC);
+
+#define wglCreatePbufferARB WGLEW_GET_FUN(__wglewCreatePbufferARB)
+#define wglDestroyPbufferARB WGLEW_GET_FUN(__wglewDestroyPbufferARB)
+#define wglGetPbufferDCARB WGLEW_GET_FUN(__wglewGetPbufferDCARB)
+#define wglQueryPbufferARB WGLEW_GET_FUN(__wglewQueryPbufferARB)
+#define wglReleasePbufferDCARB WGLEW_GET_FUN(__wglewReleasePbufferDCARB)
+
+#define WGLEW_ARB_pbuffer WGLEW_GET_VAR(__WGLEW_ARB_pbuffer)
+
+#endif /* WGL_ARB_pbuffer */
+
+/* -------------------------- WGL_ARB_pixel_format ------------------------- */
+
+#ifndef WGL_ARB_pixel_format
+#define WGL_ARB_pixel_format 1
+
+#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
+#define WGL_DRAW_TO_WINDOW_ARB 0x2001
+#define WGL_DRAW_TO_BITMAP_ARB 0x2002
+#define WGL_ACCELERATION_ARB 0x2003
+#define WGL_NEED_PALETTE_ARB 0x2004
+#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
+#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
+#define WGL_SWAP_METHOD_ARB 0x2007
+#define WGL_NUMBER_OVERLAYS_ARB 0x2008
+#define WGL_NUMBER_UNDERLAYS_ARB 0x2009
+#define WGL_TRANSPARENT_ARB 0x200A
+#define WGL_SHARE_DEPTH_ARB 0x200C
+#define WGL_SHARE_STENCIL_ARB 0x200D
+#define WGL_SHARE_ACCUM_ARB 0x200E
+#define WGL_SUPPORT_GDI_ARB 0x200F
+#define WGL_SUPPORT_OPENGL_ARB 0x2010
+#define WGL_DOUBLE_BUFFER_ARB 0x2011
+#define WGL_STEREO_ARB 0x2012
+#define WGL_PIXEL_TYPE_ARB 0x2013
+#define WGL_COLOR_BITS_ARB 0x2014
+#define WGL_RED_BITS_ARB 0x2015
+#define WGL_RED_SHIFT_ARB 0x2016
+#define WGL_GREEN_BITS_ARB 0x2017
+#define WGL_GREEN_SHIFT_ARB 0x2018
+#define WGL_BLUE_BITS_ARB 0x2019
+#define WGL_BLUE_SHIFT_ARB 0x201A
+#define WGL_ALPHA_BITS_ARB 0x201B
+#define WGL_ALPHA_SHIFT_ARB 0x201C
+#define WGL_ACCUM_BITS_ARB 0x201D
+#define WGL_ACCUM_RED_BITS_ARB 0x201E
+#define WGL_ACCUM_GREEN_BITS_ARB 0x201F
+#define WGL_ACCUM_BLUE_BITS_ARB 0x2020
+#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
+#define WGL_DEPTH_BITS_ARB 0x2022
+#define WGL_STENCIL_BITS_ARB 0x2023
+#define WGL_AUX_BUFFERS_ARB 0x2024
+#define WGL_NO_ACCELERATION_ARB 0x2025
+#define WGL_GENERIC_ACCELERATION_ARB 0x2026
+#define WGL_FULL_ACCELERATION_ARB 0x2027
+#define WGL_SWAP_EXCHANGE_ARB 0x2028
+#define WGL_SWAP_COPY_ARB 0x2029
+#define WGL_SWAP_UNDEFINED_ARB 0x202A
+#define WGL_TYPE_RGBA_ARB 0x202B
+#define WGL_TYPE_COLORINDEX_ARB 0x202C
+#define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
+#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
+#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
+#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
+#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
+
+typedef BOOL (WINAPI *PFNWGLCHOOSEPIXELFORMATARBPROC)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBFVARBPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBIVARBPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
+
+#define wglChoosePixelFormatARB WGLEW_GET_FUN(__wglewChoosePixelFormatARB)
+#define wglGetPixelFormatAttribfvARB WGLEW_GET_FUN(__wglewGetPixelFormatAttribfvARB)
+#define wglGetPixelFormatAttribivARB WGLEW_GET_FUN(__wglewGetPixelFormatAttribivARB)
+
+#define WGLEW_ARB_pixel_format WGLEW_GET_VAR(__WGLEW_ARB_pixel_format)
+
+#endif /* WGL_ARB_pixel_format */
+
+/* ----------------------- WGL_ARB_pixel_format_float ---------------------- */
+
+#ifndef WGL_ARB_pixel_format_float
+#define WGL_ARB_pixel_format_float 1
+
+#define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0
+
+#define WGLEW_ARB_pixel_format_float WGLEW_GET_VAR(__WGLEW_ARB_pixel_format_float)
+
+#endif /* WGL_ARB_pixel_format_float */
+
+/* ------------------------- WGL_ARB_render_texture ------------------------ */
+
+#ifndef WGL_ARB_render_texture
+#define WGL_ARB_render_texture 1
+
+#define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070
+#define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071
+#define WGL_TEXTURE_FORMAT_ARB 0x2072
+#define WGL_TEXTURE_TARGET_ARB 0x2073
+#define WGL_MIPMAP_TEXTURE_ARB 0x2074
+#define WGL_TEXTURE_RGB_ARB 0x2075
+#define WGL_TEXTURE_RGBA_ARB 0x2076
+#define WGL_NO_TEXTURE_ARB 0x2077
+#define WGL_TEXTURE_CUBE_MAP_ARB 0x2078
+#define WGL_TEXTURE_1D_ARB 0x2079
+#define WGL_TEXTURE_2D_ARB 0x207A
+#define WGL_MIPMAP_LEVEL_ARB 0x207B
+#define WGL_CUBE_MAP_FACE_ARB 0x207C
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082
+#define WGL_FRONT_LEFT_ARB 0x2083
+#define WGL_FRONT_RIGHT_ARB 0x2084
+#define WGL_BACK_LEFT_ARB 0x2085
+#define WGL_BACK_RIGHT_ARB 0x2086
+#define WGL_AUX0_ARB 0x2087
+#define WGL_AUX1_ARB 0x2088
+#define WGL_AUX2_ARB 0x2089
+#define WGL_AUX3_ARB 0x208A
+#define WGL_AUX4_ARB 0x208B
+#define WGL_AUX5_ARB 0x208C
+#define WGL_AUX6_ARB 0x208D
+#define WGL_AUX7_ARB 0x208E
+#define WGL_AUX8_ARB 0x208F
+#define WGL_AUX9_ARB 0x2090
+
+typedef BOOL (WINAPI *PFNWGLBINDTEXIMAGEARBPROC)(HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI *PFNWGLRELEASETEXIMAGEARBPROC)(HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI *PFNWGLSETPBUFFERATTRIBARBPROC)(HPBUFFERARB hPbuffer, const int *piAttribList);
+
+#define wglBindTexImageARB WGLEW_GET_FUN(__wglewBindTexImageARB)
+#define wglReleaseTexImageARB WGLEW_GET_FUN(__wglewReleaseTexImageARB)
+#define wglSetPbufferAttribARB WGLEW_GET_FUN(__wglewSetPbufferAttribARB)
+
+#define WGLEW_ARB_render_texture WGLEW_GET_VAR(__WGLEW_ARB_render_texture)
+
+#endif /* WGL_ARB_render_texture */
+
+/* ----------------------- WGL_ATI_pixel_format_float ---------------------- */
+
+#ifndef WGL_ATI_pixel_format_float
+#define WGL_ATI_pixel_format_float 1
+
+#define WGL_TYPE_RGBA_FLOAT_ATI 0x21A0
+#define GL_RGBA_FLOAT_MODE_ATI 0x8820
+#define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835
+
+#define WGLEW_ATI_pixel_format_float WGLEW_GET_VAR(__WGLEW_ATI_pixel_format_float)
+
+#endif /* WGL_ATI_pixel_format_float */
+
+/* -------------------- WGL_ATI_render_texture_rectangle ------------------- */
+
+#ifndef WGL_ATI_render_texture_rectangle
+#define WGL_ATI_render_texture_rectangle 1
+
+#define WGL_TEXTURE_RECTANGLE_ATI 0x21A5
+
+#define WGLEW_ATI_render_texture_rectangle WGLEW_GET_VAR(__WGLEW_ATI_render_texture_rectangle)
+
+#endif /* WGL_ATI_render_texture_rectangle */
+
+/* -------------------------- WGL_EXT_depth_float -------------------------- */
+
+#ifndef WGL_EXT_depth_float
+#define WGL_EXT_depth_float 1
+
+#define WGL_DEPTH_FLOAT_EXT 0x2040
+
+#define WGLEW_EXT_depth_float WGLEW_GET_VAR(__WGLEW_EXT_depth_float)
+
+#endif /* WGL_EXT_depth_float */
+
+/* ---------------------- WGL_EXT_display_color_table ---------------------- */
+
+#ifndef WGL_EXT_display_color_table
+#define WGL_EXT_display_color_table 1
+
+typedef GLboolean(WINAPI *PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+typedef GLboolean(WINAPI *PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+typedef void (WINAPI *PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+typedef GLboolean(WINAPI *PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)(GLushort *table, GLuint length);
+
+#define wglBindDisplayColorTableEXT WGLEW_GET_FUN(__wglewBindDisplayColorTableEXT)
+#define wglCreateDisplayColorTableEXT WGLEW_GET_FUN(__wglewCreateDisplayColorTableEXT)
+#define wglDestroyDisplayColorTableEXT WGLEW_GET_FUN(__wglewDestroyDisplayColorTableEXT)
+#define wglLoadDisplayColorTableEXT WGLEW_GET_FUN(__wglewLoadDisplayColorTableEXT)
+
+#define WGLEW_EXT_display_color_table WGLEW_GET_VAR(__WGLEW_EXT_display_color_table)
+
+#endif /* WGL_EXT_display_color_table */
+
+/* ----------------------- WGL_EXT_extensions_string ----------------------- */
+
+#ifndef WGL_EXT_extensions_string
+#define WGL_EXT_extensions_string 1
+
+typedef const char *(WINAPI *PFNWGLGETEXTENSIONSSTRINGEXTPROC)(void);
+
+#define wglGetExtensionsStringEXT WGLEW_GET_FUN(__wglewGetExtensionsStringEXT)
+
+#define WGLEW_EXT_extensions_string WGLEW_GET_VAR(__WGLEW_EXT_extensions_string)
+
+#endif /* WGL_EXT_extensions_string */
+
+/* ------------------------ WGL_EXT_framebuffer_sRGB ----------------------- */
+
+#ifndef WGL_EXT_framebuffer_sRGB
+#define WGL_EXT_framebuffer_sRGB 1
+
+#define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20A9
+
+#define WGLEW_EXT_framebuffer_sRGB WGLEW_GET_VAR(__WGLEW_EXT_framebuffer_sRGB)
+
+#endif /* WGL_EXT_framebuffer_sRGB */
+
+/* ----------------------- WGL_EXT_make_current_read ----------------------- */
+
+#ifndef WGL_EXT_make_current_read
+#define WGL_EXT_make_current_read 1
+
+typedef HDC(WINAPI *PFNWGLGETCURRENTREADDCEXTPROC)(VOID);
+typedef BOOL (WINAPI *PFNWGLMAKECONTEXTCURRENTEXTPROC)(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+
+#define wglGetCurrentReadDCEXT WGLEW_GET_FUN(__wglewGetCurrentReadDCEXT)
+#define wglMakeContextCurrentEXT WGLEW_GET_FUN(__wglewMakeContextCurrentEXT)
+
+#define WGLEW_EXT_make_current_read WGLEW_GET_VAR(__WGLEW_EXT_make_current_read)
+
+#endif /* WGL_EXT_make_current_read */
+
+/* -------------------------- WGL_EXT_multisample -------------------------- */
+
+#ifndef WGL_EXT_multisample
+#define WGL_EXT_multisample 1
+
+#define WGL_SAMPLE_BUFFERS_EXT 0x2041
+#define WGL_SAMPLES_EXT 0x2042
+
+#define WGLEW_EXT_multisample WGLEW_GET_VAR(__WGLEW_EXT_multisample)
+
+#endif /* WGL_EXT_multisample */
+
+/* ---------------------------- WGL_EXT_pbuffer ---------------------------- */
+
+#ifndef WGL_EXT_pbuffer
+#define WGL_EXT_pbuffer 1
+
+#define WGL_DRAW_TO_PBUFFER_EXT 0x202D
+#define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
+#define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
+#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
+#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
+#define WGL_PBUFFER_LARGEST_EXT 0x2033
+#define WGL_PBUFFER_WIDTH_EXT 0x2034
+#define WGL_PBUFFER_HEIGHT_EXT 0x2035
+
+DECLARE_HANDLE(HPBUFFEREXT);
+
+typedef HPBUFFEREXT(WINAPI *PFNWGLCREATEPBUFFEREXTPROC)(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef BOOL (WINAPI *PFNWGLDESTROYPBUFFEREXTPROC)(HPBUFFEREXT hPbuffer);
+typedef HDC(WINAPI *PFNWGLGETPBUFFERDCEXTPROC)(HPBUFFEREXT hPbuffer);
+typedef BOOL (WINAPI *PFNWGLQUERYPBUFFEREXTPROC)(HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
+typedef int (WINAPI *PFNWGLRELEASEPBUFFERDCEXTPROC)(HPBUFFEREXT hPbuffer, HDC hDC);
+
+#define wglCreatePbufferEXT WGLEW_GET_FUN(__wglewCreatePbufferEXT)
+#define wglDestroyPbufferEXT WGLEW_GET_FUN(__wglewDestroyPbufferEXT)
+#define wglGetPbufferDCEXT WGLEW_GET_FUN(__wglewGetPbufferDCEXT)
+#define wglQueryPbufferEXT WGLEW_GET_FUN(__wglewQueryPbufferEXT)
+#define wglReleasePbufferDCEXT WGLEW_GET_FUN(__wglewReleasePbufferDCEXT)
+
+#define WGLEW_EXT_pbuffer WGLEW_GET_VAR(__WGLEW_EXT_pbuffer)
+
+#endif /* WGL_EXT_pbuffer */
+
+/* -------------------------- WGL_EXT_pixel_format ------------------------- */
+
+#ifndef WGL_EXT_pixel_format
+#define WGL_EXT_pixel_format 1
+
+#define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
+#define WGL_DRAW_TO_WINDOW_EXT 0x2001
+#define WGL_DRAW_TO_BITMAP_EXT 0x2002
+#define WGL_ACCELERATION_EXT 0x2003
+#define WGL_NEED_PALETTE_EXT 0x2004
+#define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
+#define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
+#define WGL_SWAP_METHOD_EXT 0x2007
+#define WGL_NUMBER_OVERLAYS_EXT 0x2008
+#define WGL_NUMBER_UNDERLAYS_EXT 0x2009
+#define WGL_TRANSPARENT_EXT 0x200A
+#define WGL_TRANSPARENT_VALUE_EXT 0x200B
+#define WGL_SHARE_DEPTH_EXT 0x200C
+#define WGL_SHARE_STENCIL_EXT 0x200D
+#define WGL_SHARE_ACCUM_EXT 0x200E
+#define WGL_SUPPORT_GDI_EXT 0x200F
+#define WGL_SUPPORT_OPENGL_EXT 0x2010
+#define WGL_DOUBLE_BUFFER_EXT 0x2011
+#define WGL_STEREO_EXT 0x2012
+#define WGL_PIXEL_TYPE_EXT 0x2013
+#define WGL_COLOR_BITS_EXT 0x2014
+#define WGL_RED_BITS_EXT 0x2015
+#define WGL_RED_SHIFT_EXT 0x2016
+#define WGL_GREEN_BITS_EXT 0x2017
+#define WGL_GREEN_SHIFT_EXT 0x2018
+#define WGL_BLUE_BITS_EXT 0x2019
+#define WGL_BLUE_SHIFT_EXT 0x201A
+#define WGL_ALPHA_BITS_EXT 0x201B
+#define WGL_ALPHA_SHIFT_EXT 0x201C
+#define WGL_ACCUM_BITS_EXT 0x201D
+#define WGL_ACCUM_RED_BITS_EXT 0x201E
+#define WGL_ACCUM_GREEN_BITS_EXT 0x201F
+#define WGL_ACCUM_BLUE_BITS_EXT 0x2020
+#define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
+#define WGL_DEPTH_BITS_EXT 0x2022
+#define WGL_STENCIL_BITS_EXT 0x2023
+#define WGL_AUX_BUFFERS_EXT 0x2024
+#define WGL_NO_ACCELERATION_EXT 0x2025
+#define WGL_GENERIC_ACCELERATION_EXT 0x2026
+#define WGL_FULL_ACCELERATION_EXT 0x2027
+#define WGL_SWAP_EXCHANGE_EXT 0x2028
+#define WGL_SWAP_COPY_EXT 0x2029
+#define WGL_SWAP_UNDEFINED_EXT 0x202A
+#define WGL_TYPE_RGBA_EXT 0x202B
+#define WGL_TYPE_COLORINDEX_EXT 0x202C
+
+typedef BOOL (WINAPI *PFNWGLCHOOSEPIXELFORMATEXTPROC)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
+
+#define wglChoosePixelFormatEXT WGLEW_GET_FUN(__wglewChoosePixelFormatEXT)
+#define wglGetPixelFormatAttribfvEXT WGLEW_GET_FUN(__wglewGetPixelFormatAttribfvEXT)
+#define wglGetPixelFormatAttribivEXT WGLEW_GET_FUN(__wglewGetPixelFormatAttribivEXT)
+
+#define WGLEW_EXT_pixel_format WGLEW_GET_VAR(__WGLEW_EXT_pixel_format)
+
+#endif /* WGL_EXT_pixel_format */
+
+/* ------------------- WGL_EXT_pixel_format_packed_float ------------------- */
+
+#ifndef WGL_EXT_pixel_format_packed_float
+#define WGL_EXT_pixel_format_packed_float 1
+
+#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8
+
+#define WGLEW_EXT_pixel_format_packed_float WGLEW_GET_VAR(__WGLEW_EXT_pixel_format_packed_float)
+
+#endif /* WGL_EXT_pixel_format_packed_float */
+
+/* -------------------------- WGL_EXT_swap_control ------------------------- */
+
+#ifndef WGL_EXT_swap_control
+#define WGL_EXT_swap_control 1
+
+typedef int (WINAPI *PFNWGLGETSWAPINTERVALEXTPROC)(void);
+typedef BOOL (WINAPI *PFNWGLSWAPINTERVALEXTPROC)(int interval);
+
+#define wglGetSwapIntervalEXT WGLEW_GET_FUN(__wglewGetSwapIntervalEXT)
+#define wglSwapIntervalEXT WGLEW_GET_FUN(__wglewSwapIntervalEXT)
+
+#define WGLEW_EXT_swap_control WGLEW_GET_VAR(__WGLEW_EXT_swap_control)
+
+#endif /* WGL_EXT_swap_control */
+
+/* --------------------- WGL_I3D_digital_video_control --------------------- */
+
+#ifndef WGL_I3D_digital_video_control
+#define WGL_I3D_digital_video_control 1
+
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
+#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
+#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
+
+typedef BOOL (WINAPI *PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)(HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (WINAPI *PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)(HDC hDC, int iAttribute, const int *piValue);
+
+#define wglGetDigitalVideoParametersI3D WGLEW_GET_FUN(__wglewGetDigitalVideoParametersI3D)
+#define wglSetDigitalVideoParametersI3D WGLEW_GET_FUN(__wglewSetDigitalVideoParametersI3D)
+
+#define WGLEW_I3D_digital_video_control WGLEW_GET_VAR(__WGLEW_I3D_digital_video_control)
+
+#endif /* WGL_I3D_digital_video_control */
+
+/* ----------------------------- WGL_I3D_gamma ----------------------------- */
+
+#ifndef WGL_I3D_gamma
+#define WGL_I3D_gamma 1
+
+#define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
+#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
+
+typedef BOOL (WINAPI *PFNWGLGETGAMMATABLEI3DPROC)(HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
+typedef BOOL (WINAPI *PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)(HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (WINAPI *PFNWGLSETGAMMATABLEI3DPROC)(HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
+typedef BOOL (WINAPI *PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)(HDC hDC, int iAttribute, const int *piValue);
+
+#define wglGetGammaTableI3D WGLEW_GET_FUN(__wglewGetGammaTableI3D)
+#define wglGetGammaTableParametersI3D WGLEW_GET_FUN(__wglewGetGammaTableParametersI3D)
+#define wglSetGammaTableI3D WGLEW_GET_FUN(__wglewSetGammaTableI3D)
+#define wglSetGammaTableParametersI3D WGLEW_GET_FUN(__wglewSetGammaTableParametersI3D)
+
+#define WGLEW_I3D_gamma WGLEW_GET_VAR(__WGLEW_I3D_gamma)
+
+#endif /* WGL_I3D_gamma */
+
+/* ---------------------------- WGL_I3D_genlock ---------------------------- */
+
+#ifndef WGL_I3D_genlock
+#define WGL_I3D_genlock 1
+
+#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
+#define WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D 0x2045
+#define WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D 0x2046
+#define WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D 0x2047
+#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
+#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
+#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
+#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
+#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
+
+typedef BOOL (WINAPI *PFNWGLDISABLEGENLOCKI3DPROC)(HDC hDC);
+typedef BOOL (WINAPI *PFNWGLENABLEGENLOCKI3DPROC)(HDC hDC);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSAMPLERATEI3DPROC)(HDC hDC, UINT uRate);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEDELAYI3DPROC)(HDC hDC, UINT uDelay);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEEDGEI3DPROC)(HDC hDC, UINT uEdge);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEI3DPROC)(HDC hDC, UINT uSource);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSAMPLERATEI3DPROC)(HDC hDC, UINT *uRate);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)(HDC hDC, UINT *uDelay);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)(HDC hDC, UINT *uEdge);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEI3DPROC)(HDC hDC, UINT *uSource);
+typedef BOOL (WINAPI *PFNWGLISENABLEDGENLOCKI3DPROC)(HDC hDC, BOOL *pFlag);
+typedef BOOL (WINAPI *PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)(HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
+
+#define wglDisableGenlockI3D WGLEW_GET_FUN(__wglewDisableGenlockI3D)
+#define wglEnableGenlockI3D WGLEW_GET_FUN(__wglewEnableGenlockI3D)
+#define wglGenlockSampleRateI3D WGLEW_GET_FUN(__wglewGenlockSampleRateI3D)
+#define wglGenlockSourceDelayI3D WGLEW_GET_FUN(__wglewGenlockSourceDelayI3D)
+#define wglGenlockSourceEdgeI3D WGLEW_GET_FUN(__wglewGenlockSourceEdgeI3D)
+#define wglGenlockSourceI3D WGLEW_GET_FUN(__wglewGenlockSourceI3D)
+#define wglGetGenlockSampleRateI3D WGLEW_GET_FUN(__wglewGetGenlockSampleRateI3D)
+#define wglGetGenlockSourceDelayI3D WGLEW_GET_FUN(__wglewGetGenlockSourceDelayI3D)
+#define wglGetGenlockSourceEdgeI3D WGLEW_GET_FUN(__wglewGetGenlockSourceEdgeI3D)
+#define wglGetGenlockSourceI3D WGLEW_GET_FUN(__wglewGetGenlockSourceI3D)
+#define wglIsEnabledGenlockI3D WGLEW_GET_FUN(__wglewIsEnabledGenlockI3D)
+#define wglQueryGenlockMaxSourceDelayI3D WGLEW_GET_FUN(__wglewQueryGenlockMaxSourceDelayI3D)
+
+#define WGLEW_I3D_genlock WGLEW_GET_VAR(__WGLEW_I3D_genlock)
+
+#endif /* WGL_I3D_genlock */
+
+/* -------------------------- WGL_I3D_image_buffer ------------------------- */
+
+#ifndef WGL_I3D_image_buffer
+#define WGL_I3D_image_buffer 1
+
+#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001
+#define WGL_IMAGE_BUFFER_LOCK_I3D 0x00000002
+
+typedef BOOL (WINAPI *PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)(HDC hdc, HANDLE *pEvent, LPVOID *pAddress, DWORD *pSize, UINT count);
+typedef LPVOID (WINAPI *PFNWGLCREATEIMAGEBUFFERI3DPROC)(HDC hDC, DWORD dwSize, UINT uFlags);
+typedef BOOL (WINAPI *PFNWGLDESTROYIMAGEBUFFERI3DPROC)(HDC hDC, LPVOID pAddress);
+typedef BOOL (WINAPI *PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)(HDC hdc, LPVOID *pAddress, UINT count);
+
+#define wglAssociateImageBufferEventsI3D WGLEW_GET_FUN(__wglewAssociateImageBufferEventsI3D)
+#define wglCreateImageBufferI3D WGLEW_GET_FUN(__wglewCreateImageBufferI3D)
+#define wglDestroyImageBufferI3D WGLEW_GET_FUN(__wglewDestroyImageBufferI3D)
+#define wglReleaseImageBufferEventsI3D WGLEW_GET_FUN(__wglewReleaseImageBufferEventsI3D)
+
+#define WGLEW_I3D_image_buffer WGLEW_GET_VAR(__WGLEW_I3D_image_buffer)
+
+#endif /* WGL_I3D_image_buffer */
+
+/* ------------------------ WGL_I3D_swap_frame_lock ------------------------ */
+
+#ifndef WGL_I3D_swap_frame_lock
+#define WGL_I3D_swap_frame_lock 1
+
+typedef BOOL (WINAPI *PFNWGLDISABLEFRAMELOCKI3DPROC)(VOID);
+typedef BOOL (WINAPI *PFNWGLENABLEFRAMELOCKI3DPROC)(VOID);
+typedef BOOL (WINAPI *PFNWGLISENABLEDFRAMELOCKI3DPROC)(BOOL *pFlag);
+typedef BOOL (WINAPI *PFNWGLQUERYFRAMELOCKMASTERI3DPROC)(BOOL *pFlag);
+
+#define wglDisableFrameLockI3D WGLEW_GET_FUN(__wglewDisableFrameLockI3D)
+#define wglEnableFrameLockI3D WGLEW_GET_FUN(__wglewEnableFrameLockI3D)
+#define wglIsEnabledFrameLockI3D WGLEW_GET_FUN(__wglewIsEnabledFrameLockI3D)
+#define wglQueryFrameLockMasterI3D WGLEW_GET_FUN(__wglewQueryFrameLockMasterI3D)
+
+#define WGLEW_I3D_swap_frame_lock WGLEW_GET_VAR(__WGLEW_I3D_swap_frame_lock)
+
+#endif /* WGL_I3D_swap_frame_lock */
+
+/* ------------------------ WGL_I3D_swap_frame_usage ----------------------- */
+
+#ifndef WGL_I3D_swap_frame_usage
+#define WGL_I3D_swap_frame_usage 1
+
+typedef BOOL (WINAPI *PFNWGLBEGINFRAMETRACKINGI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLENDFRAMETRACKINGI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLGETFRAMEUSAGEI3DPROC)(float *pUsage);
+typedef BOOL (WINAPI *PFNWGLQUERYFRAMETRACKINGI3DPROC)(DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
+
+#define wglBeginFrameTrackingI3D WGLEW_GET_FUN(__wglewBeginFrameTrackingI3D)
+#define wglEndFrameTrackingI3D WGLEW_GET_FUN(__wglewEndFrameTrackingI3D)
+#define wglGetFrameUsageI3D WGLEW_GET_FUN(__wglewGetFrameUsageI3D)
+#define wglQueryFrameTrackingI3D WGLEW_GET_FUN(__wglewQueryFrameTrackingI3D)
+
+#define WGLEW_I3D_swap_frame_usage WGLEW_GET_VAR(__WGLEW_I3D_swap_frame_usage)
+
+#endif /* WGL_I3D_swap_frame_usage */
+
+/* -------------------------- WGL_NV_float_buffer -------------------------- */
+
+#ifndef WGL_NV_float_buffer
+#define WGL_NV_float_buffer 1
+
+#define WGL_FLOAT_COMPONENTS_NV 0x20B0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4
+#define WGL_TEXTURE_FLOAT_R_NV 0x20B5
+#define WGL_TEXTURE_FLOAT_RG_NV 0x20B6
+#define WGL_TEXTURE_FLOAT_RGB_NV 0x20B7
+#define WGL_TEXTURE_FLOAT_RGBA_NV 0x20B8
+
+#define WGLEW_NV_float_buffer WGLEW_GET_VAR(__WGLEW_NV_float_buffer)
+
+#endif /* WGL_NV_float_buffer */
+
+/* ---------------------- WGL_NV_render_depth_texture ---------------------- */
+
+#ifndef WGL_NV_render_depth_texture
+#define WGL_NV_render_depth_texture 1
+
+#define WGL_NO_TEXTURE_ARB 0x2077
+#define WGL_BIND_TO_TEXTURE_DEPTH_NV 0x20A3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4
+#define WGL_DEPTH_TEXTURE_FORMAT_NV 0x20A5
+#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6
+#define WGL_DEPTH_COMPONENT_NV 0x20A7
+
+#define WGLEW_NV_render_depth_texture WGLEW_GET_VAR(__WGLEW_NV_render_depth_texture)
+
+#endif /* WGL_NV_render_depth_texture */
+
+/* -------------------- WGL_NV_render_texture_rectangle -------------------- */
+
+#ifndef WGL_NV_render_texture_rectangle
+#define WGL_NV_render_texture_rectangle 1
+
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1
+#define WGL_TEXTURE_RECTANGLE_NV 0x20A2
+
+#define WGLEW_NV_render_texture_rectangle WGLEW_GET_VAR(__WGLEW_NV_render_texture_rectangle)
+
+#endif /* WGL_NV_render_texture_rectangle */
+
+/* ----------------------- WGL_NV_vertex_array_range ----------------------- */
+
+#ifndef WGL_NV_vertex_array_range
+#define WGL_NV_vertex_array_range 1
+
+typedef void *(WINAPI *PFNWGLALLOCATEMEMORYNVPROC)(GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
+typedef void (WINAPI *PFNWGLFREEMEMORYNVPROC)(void *pointer);
+
+#define wglAllocateMemoryNV WGLEW_GET_FUN(__wglewAllocateMemoryNV)
+#define wglFreeMemoryNV WGLEW_GET_FUN(__wglewFreeMemoryNV)
+
+#define WGLEW_NV_vertex_array_range WGLEW_GET_VAR(__WGLEW_NV_vertex_array_range)
+
+#endif /* WGL_NV_vertex_array_range */
+
+/* -------------------------- WGL_OML_sync_control ------------------------- */
+
+#ifndef WGL_OML_sync_control
+#define WGL_OML_sync_control 1
+
+typedef BOOL (WINAPI *PFNWGLGETMSCRATEOMLPROC)(HDC hdc, INT32 *numerator, INT32 *denominator);
+typedef BOOL (WINAPI *PFNWGLGETSYNCVALUESOMLPROC)(HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef INT64(WINAPI *PFNWGLSWAPBUFFERSMSCOMLPROC)(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef INT64(WINAPI *PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)(HDC hdc, INT fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef BOOL (WINAPI *PFNWGLWAITFORMSCOMLPROC)(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef BOOL (WINAPI *PFNWGLWAITFORSBCOMLPROC)(HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
+
+#define wglGetMscRateOML WGLEW_GET_FUN(__wglewGetMscRateOML)
+#define wglGetSyncValuesOML WGLEW_GET_FUN(__wglewGetSyncValuesOML)
+#define wglSwapBuffersMscOML WGLEW_GET_FUN(__wglewSwapBuffersMscOML)
+#define wglSwapLayerBuffersMscOML WGLEW_GET_FUN(__wglewSwapLayerBuffersMscOML)
+#define wglWaitForMscOML WGLEW_GET_FUN(__wglewWaitForMscOML)
+#define wglWaitForSbcOML WGLEW_GET_FUN(__wglewWaitForSbcOML)
+
+#define WGLEW_OML_sync_control WGLEW_GET_VAR(__WGLEW_OML_sync_control)
+
+#endif /* WGL_OML_sync_control */
+
+/* ------------------------------------------------------------------------- */
+
+#ifdef GLEW_MX
+#define WGLEW_EXPORT
+#else
+#define WGLEW_EXPORT GLEWAPI
+#endif /* GLEW_MX */
+
+#ifdef GLEW_MX
+struct WGLEWContextStruct
+{
+#endif /* GLEW_MX */
+
+    WGLEW_EXPORT PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL;
+
+    WGLEW_EXPORT PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB;
+    WGLEW_EXPORT PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB;
+    WGLEW_EXPORT PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB;
+    WGLEW_EXPORT PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB;
+
+    WGLEW_EXPORT PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB;
+
+    WGLEW_EXPORT PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB;
+    WGLEW_EXPORT PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB;
+
+    WGLEW_EXPORT PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB;
+    WGLEW_EXPORT PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB;
+    WGLEW_EXPORT PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB;
+    WGLEW_EXPORT PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB;
+    WGLEW_EXPORT PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB;
+
+    WGLEW_EXPORT PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB;
+    WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB;
+    WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB;
+
+    WGLEW_EXPORT PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB;
+    WGLEW_EXPORT PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB;
+    WGLEW_EXPORT PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB;
+
+    WGLEW_EXPORT PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT;
+    WGLEW_EXPORT PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT;
+    WGLEW_EXPORT PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT;
+    WGLEW_EXPORT PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT;
+
+    WGLEW_EXPORT PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT;
+
+    WGLEW_EXPORT PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT;
+    WGLEW_EXPORT PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT;
+
+    WGLEW_EXPORT PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT;
+    WGLEW_EXPORT PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT;
+    WGLEW_EXPORT PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT;
+    WGLEW_EXPORT PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT;
+    WGLEW_EXPORT PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT;
+
+    WGLEW_EXPORT PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT;
+    WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT;
+    WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT;
+
+    WGLEW_EXPORT PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT;
+    WGLEW_EXPORT PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT;
+
+    WGLEW_EXPORT PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D;
+    WGLEW_EXPORT PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D;
+
+    WGLEW_EXPORT PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D;
+    WGLEW_EXPORT PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D;
+    WGLEW_EXPORT PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D;
+    WGLEW_EXPORT PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D;
+
+    WGLEW_EXPORT PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D;
+    WGLEW_EXPORT PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D;
+    WGLEW_EXPORT PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D;
+    WGLEW_EXPORT PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D;
+    WGLEW_EXPORT PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D;
+    WGLEW_EXPORT PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D;
+    WGLEW_EXPORT PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D;
+    WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D;
+    WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D;
+    WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D;
+    WGLEW_EXPORT PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D;
+    WGLEW_EXPORT PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D;
+
+    WGLEW_EXPORT PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D;
+    WGLEW_EXPORT PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D;
+    WGLEW_EXPORT PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D;
+    WGLEW_EXPORT PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D;
+
+    WGLEW_EXPORT PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D;
+    WGLEW_EXPORT PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D;
+    WGLEW_EXPORT PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D;
+    WGLEW_EXPORT PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D;
+
+    WGLEW_EXPORT PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D;
+    WGLEW_EXPORT PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D;
+    WGLEW_EXPORT PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D;
+    WGLEW_EXPORT PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D;
+
+    WGLEW_EXPORT PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV;
+    WGLEW_EXPORT PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV;
+
+    WGLEW_EXPORT PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML;
+    WGLEW_EXPORT PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML;
+    WGLEW_EXPORT PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML;
+    WGLEW_EXPORT PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML;
+    WGLEW_EXPORT PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML;
+    WGLEW_EXPORT PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML;
+    WGLEW_EXPORT GLboolean __WGLEW_3DFX_multisample;
+    WGLEW_EXPORT GLboolean __WGLEW_3DL_stereo_control;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_buffer_region;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_extensions_string;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_make_current_read;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_multisample;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_pbuffer;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_pixel_format;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_pixel_format_float;
+    WGLEW_EXPORT GLboolean __WGLEW_ARB_render_texture;
+    WGLEW_EXPORT GLboolean __WGLEW_ATI_pixel_format_float;
+    WGLEW_EXPORT GLboolean __WGLEW_ATI_render_texture_rectangle;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_depth_float;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_display_color_table;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_extensions_string;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_framebuffer_sRGB;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_make_current_read;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_multisample;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_pbuffer;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_pixel_format;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_pixel_format_packed_float;
+    WGLEW_EXPORT GLboolean __WGLEW_EXT_swap_control;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_digital_video_control;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_gamma;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_genlock;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_image_buffer;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_swap_frame_lock;
+    WGLEW_EXPORT GLboolean __WGLEW_I3D_swap_frame_usage;
+    WGLEW_EXPORT GLboolean __WGLEW_NV_float_buffer;
+    WGLEW_EXPORT GLboolean __WGLEW_NV_render_depth_texture;
+    WGLEW_EXPORT GLboolean __WGLEW_NV_render_texture_rectangle;
+    WGLEW_EXPORT GLboolean __WGLEW_NV_vertex_array_range;
+    WGLEW_EXPORT GLboolean __WGLEW_OML_sync_control;
+
+#ifdef GLEW_MX
+}; /* WGLEWContextStruct */
+#endif /* GLEW_MX */
+
+/* ------------------------------------------------------------------------- */
+
+#ifdef GLEW_MX
+
+typedef struct WGLEWContextStruct WGLEWContext;
+GLEWAPI GLenum wglewContextInit(WGLEWContext *ctx);
+GLEWAPI GLboolean wglewContextIsSupported(WGLEWContext *ctx, const char *name);
+
+#define wglewInit() wglewContextInit(wglewGetContext())
+#define wglewIsSupported(x) wglewContextIsSupported(wglewGetContext(), x)
+
+#define WGLEW_GET_VAR(x) wglewGetContext()->x
+#define WGLEW_GET_FUN(x) wglewGetContext()->x
+
+#else /* GLEW_MX */
+
+#define WGLEW_GET_VAR(x) x
+#define WGLEW_GET_FUN(x) x
+
+GLEWAPI GLboolean wglewIsSupported(const char *name);
+
+#endif /* GLEW_MX */
+
+GLEWAPI GLboolean wglewGetExtension(const char *name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#undef GLEWAPI
+
+#endif /* __wglew_h__ */

Common/GL/wglext.h

@@ -0,0 +1,696 @@
+#ifndef __wglext_h_
+#define __wglext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+**
+** http://oss.sgi.com/projects/FreeB
+**
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+**
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2004 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+**
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+#ifndef GLAPI
+#define GLAPI extern
+#endif
+
+
+/*************************************************************/
+
+/* Header file version number */
+/* wglext.h last updated 2005/01/07 */
+/* Current version at http://oss.sgi.com/projects/ogl-sample/registry/ */
+#define WGL_WGLEXT_VERSION 6
+
+#ifndef WGL_ARB_buffer_region
+#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
+#define WGL_BACK_COLOR_BUFFER_BIT_ARB  0x00000002
+#define WGL_DEPTH_BUFFER_BIT_ARB       0x00000004
+#define WGL_STENCIL_BUFFER_BIT_ARB     0x00000008
+#endif
+
+#ifndef WGL_ARB_multisample
+#define WGL_SAMPLE_BUFFERS_ARB         0x2041
+#define WGL_SAMPLES_ARB                0x2042
+#endif
+
+#ifndef WGL_ARB_extensions_string
+#endif
+
+#ifndef WGL_ARB_pixel_format
+#define WGL_NUMBER_PIXEL_FORMATS_ARB   0x2000
+#define WGL_DRAW_TO_WINDOW_ARB         0x2001
+#define WGL_DRAW_TO_BITMAP_ARB         0x2002
+#define WGL_ACCELERATION_ARB           0x2003
+#define WGL_NEED_PALETTE_ARB           0x2004
+#define WGL_NEED_SYSTEM_PALETTE_ARB    0x2005
+#define WGL_SWAP_LAYER_BUFFERS_ARB     0x2006
+#define WGL_SWAP_METHOD_ARB            0x2007
+#define WGL_NUMBER_OVERLAYS_ARB        0x2008
+#define WGL_NUMBER_UNDERLAYS_ARB       0x2009
+#define WGL_TRANSPARENT_ARB            0x200A
+#define WGL_TRANSPARENT_RED_VALUE_ARB  0x2037
+#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
+#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
+#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
+#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
+#define WGL_SHARE_DEPTH_ARB            0x200C
+#define WGL_SHARE_STENCIL_ARB          0x200D
+#define WGL_SHARE_ACCUM_ARB            0x200E
+#define WGL_SUPPORT_GDI_ARB            0x200F
+#define WGL_SUPPORT_OPENGL_ARB         0x2010
+#define WGL_DOUBLE_BUFFER_ARB          0x2011
+#define WGL_STEREO_ARB                 0x2012
+#define WGL_PIXEL_TYPE_ARB             0x2013
+#define WGL_COLOR_BITS_ARB             0x2014
+#define WGL_RED_BITS_ARB               0x2015
+#define WGL_RED_SHIFT_ARB              0x2016
+#define WGL_GREEN_BITS_ARB             0x2017
+#define WGL_GREEN_SHIFT_ARB            0x2018
+#define WGL_BLUE_BITS_ARB              0x2019
+#define WGL_BLUE_SHIFT_ARB             0x201A
+#define WGL_ALPHA_BITS_ARB             0x201B
+#define WGL_ALPHA_SHIFT_ARB            0x201C
+#define WGL_ACCUM_BITS_ARB             0x201D
+#define WGL_ACCUM_RED_BITS_ARB         0x201E
+#define WGL_ACCUM_GREEN_BITS_ARB       0x201F
+#define WGL_ACCUM_BLUE_BITS_ARB        0x2020
+#define WGL_ACCUM_ALPHA_BITS_ARB       0x2021
+#define WGL_DEPTH_BITS_ARB             0x2022
+#define WGL_STENCIL_BITS_ARB           0x2023
+#define WGL_AUX_BUFFERS_ARB            0x2024
+#define WGL_NO_ACCELERATION_ARB        0x2025
+#define WGL_GENERIC_ACCELERATION_ARB   0x2026
+#define WGL_FULL_ACCELERATION_ARB      0x2027
+#define WGL_SWAP_EXCHANGE_ARB          0x2028
+#define WGL_SWAP_COPY_ARB              0x2029
+#define WGL_SWAP_UNDEFINED_ARB         0x202A
+#define WGL_TYPE_RGBA_ARB              0x202B
+#define WGL_TYPE_COLORINDEX_ARB        0x202C
+#endif
+
+#ifndef WGL_ARB_make_current_read
+#define ERROR_INVALID_PIXEL_TYPE_ARB   0x2043
+#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
+#endif
+
+#ifndef WGL_ARB_pbuffer
+#define WGL_DRAW_TO_PBUFFER_ARB        0x202D
+#define WGL_MAX_PBUFFER_PIXELS_ARB     0x202E
+#define WGL_MAX_PBUFFER_WIDTH_ARB      0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_ARB     0x2030
+#define WGL_PBUFFER_LARGEST_ARB        0x2033
+#define WGL_PBUFFER_WIDTH_ARB          0x2034
+#define WGL_PBUFFER_HEIGHT_ARB         0x2035
+#define WGL_PBUFFER_LOST_ARB           0x2036
+#endif
+
+#ifndef WGL_ARB_render_texture
+#define WGL_BIND_TO_TEXTURE_RGB_ARB    0x2070
+#define WGL_BIND_TO_TEXTURE_RGBA_ARB   0x2071
+#define WGL_TEXTURE_FORMAT_ARB         0x2072
+#define WGL_TEXTURE_TARGET_ARB         0x2073
+#define WGL_MIPMAP_TEXTURE_ARB         0x2074
+#define WGL_TEXTURE_RGB_ARB            0x2075
+#define WGL_TEXTURE_RGBA_ARB           0x2076
+#define WGL_NO_TEXTURE_ARB             0x2077
+#define WGL_TEXTURE_CUBE_MAP_ARB       0x2078
+#define WGL_TEXTURE_1D_ARB             0x2079
+#define WGL_TEXTURE_2D_ARB             0x207A
+#define WGL_MIPMAP_LEVEL_ARB           0x207B
+#define WGL_CUBE_MAP_FACE_ARB          0x207C
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082
+#define WGL_FRONT_LEFT_ARB             0x2083
+#define WGL_FRONT_RIGHT_ARB            0x2084
+#define WGL_BACK_LEFT_ARB              0x2085
+#define WGL_BACK_RIGHT_ARB             0x2086
+#define WGL_AUX0_ARB                   0x2087
+#define WGL_AUX1_ARB                   0x2088
+#define WGL_AUX2_ARB                   0x2089
+#define WGL_AUX3_ARB                   0x208A
+#define WGL_AUX4_ARB                   0x208B
+#define WGL_AUX5_ARB                   0x208C
+#define WGL_AUX6_ARB                   0x208D
+#define WGL_AUX7_ARB                   0x208E
+#define WGL_AUX8_ARB                   0x208F
+#define WGL_AUX9_ARB                   0x2090
+#endif
+
+#ifndef WGL_ARB_pixel_format_float
+#define WGL_TYPE_RGBA_FLOAT_ARB        0x21A0
+#endif
+
+#ifndef WGL_EXT_make_current_read
+#define ERROR_INVALID_PIXEL_TYPE_EXT   0x2043
+#endif
+
+#ifndef WGL_EXT_pixel_format
+#define WGL_NUMBER_PIXEL_FORMATS_EXT   0x2000
+#define WGL_DRAW_TO_WINDOW_EXT         0x2001
+#define WGL_DRAW_TO_BITMAP_EXT         0x2002
+#define WGL_ACCELERATION_EXT           0x2003
+#define WGL_NEED_PALETTE_EXT           0x2004
+#define WGL_NEED_SYSTEM_PALETTE_EXT    0x2005
+#define WGL_SWAP_LAYER_BUFFERS_EXT     0x2006
+#define WGL_SWAP_METHOD_EXT            0x2007
+#define WGL_NUMBER_OVERLAYS_EXT        0x2008
+#define WGL_NUMBER_UNDERLAYS_EXT       0x2009
+#define WGL_TRANSPARENT_EXT            0x200A
+#define WGL_TRANSPARENT_VALUE_EXT      0x200B
+#define WGL_SHARE_DEPTH_EXT            0x200C
+#define WGL_SHARE_STENCIL_EXT          0x200D
+#define WGL_SHARE_ACCUM_EXT            0x200E
+#define WGL_SUPPORT_GDI_EXT            0x200F
+#define WGL_SUPPORT_OPENGL_EXT         0x2010
+#define WGL_DOUBLE_BUFFER_EXT          0x2011
+#define WGL_STEREO_EXT                 0x2012
+#define WGL_PIXEL_TYPE_EXT             0x2013
+#define WGL_COLOR_BITS_EXT             0x2014
+#define WGL_RED_BITS_EXT               0x2015
+#define WGL_RED_SHIFT_EXT              0x2016
+#define WGL_GREEN_BITS_EXT             0x2017
+#define WGL_GREEN_SHIFT_EXT            0x2018
+#define WGL_BLUE_BITS_EXT              0x2019
+#define WGL_BLUE_SHIFT_EXT             0x201A
+#define WGL_ALPHA_BITS_EXT             0x201B
+#define WGL_ALPHA_SHIFT_EXT            0x201C
+#define WGL_ACCUM_BITS_EXT             0x201D
+#define WGL_ACCUM_RED_BITS_EXT         0x201E
+#define WGL_ACCUM_GREEN_BITS_EXT       0x201F
+#define WGL_ACCUM_BLUE_BITS_EXT        0x2020
+#define WGL_ACCUM_ALPHA_BITS_EXT       0x2021
+#define WGL_DEPTH_BITS_EXT             0x2022
+#define WGL_STENCIL_BITS_EXT           0x2023
+#define WGL_AUX_BUFFERS_EXT            0x2024
+#define WGL_NO_ACCELERATION_EXT        0x2025
+#define WGL_GENERIC_ACCELERATION_EXT   0x2026
+#define WGL_FULL_ACCELERATION_EXT      0x2027
+#define WGL_SWAP_EXCHANGE_EXT          0x2028
+#define WGL_SWAP_COPY_EXT              0x2029
+#define WGL_SWAP_UNDEFINED_EXT         0x202A
+#define WGL_TYPE_RGBA_EXT              0x202B
+#define WGL_TYPE_COLORINDEX_EXT        0x202C
+#endif
+
+#ifndef WGL_EXT_pbuffer
+#define WGL_DRAW_TO_PBUFFER_EXT        0x202D
+#define WGL_MAX_PBUFFER_PIXELS_EXT     0x202E
+#define WGL_MAX_PBUFFER_WIDTH_EXT      0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_EXT     0x2030
+#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT  0x2031
+#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
+#define WGL_PBUFFER_LARGEST_EXT        0x2033
+#define WGL_PBUFFER_WIDTH_EXT          0x2034
+#define WGL_PBUFFER_HEIGHT_EXT         0x2035
+#endif
+
+#ifndef WGL_EXT_depth_float
+#define WGL_DEPTH_FLOAT_EXT            0x2040
+#endif
+
+#ifndef WGL_3DFX_multisample
+#define WGL_SAMPLE_BUFFERS_3DFX        0x2060
+#define WGL_SAMPLES_3DFX               0x2061
+#endif
+
+#ifndef WGL_EXT_multisample
+#define WGL_SAMPLE_BUFFERS_EXT         0x2041
+#define WGL_SAMPLES_EXT                0x2042
+#endif
+
+#ifndef WGL_I3D_digital_video_control
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
+#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
+#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
+#endif
+
+#ifndef WGL_I3D_gamma
+#define WGL_GAMMA_TABLE_SIZE_I3D       0x204E
+#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D  0x204F
+#endif
+
+#ifndef WGL_I3D_genlock
+#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
+#define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045
+#define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046
+#define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047
+#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
+#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
+#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
+#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
+#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
+#endif
+
+#ifndef WGL_I3D_image_buffer
+#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001
+#define WGL_IMAGE_BUFFER_LOCK_I3D      0x00000002
+#endif
+
+#ifndef WGL_I3D_swap_frame_lock
+#endif
+
+#ifndef WGL_NV_render_depth_texture
+#define WGL_BIND_TO_TEXTURE_DEPTH_NV   0x20A3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4
+#define WGL_DEPTH_TEXTURE_FORMAT_NV    0x20A5
+#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6
+#define WGL_DEPTH_COMPONENT_NV         0x20A7
+#endif
+
+#ifndef WGL_NV_render_texture_rectangle
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1
+#define WGL_TEXTURE_RECTANGLE_NV       0x20A2
+#endif
+
+#ifndef WGL_ATI_pixel_format_float
+#define WGL_TYPE_RGBA_FLOAT_ATI        0x21A0
+#define WGL_RGBA_FLOAT_MODE_ATI        0x8820
+#define WGL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835
+#endif
+
+#ifndef WGL_NV_float_buffer
+#define WGL_FLOAT_COMPONENTS_NV        0x20B0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4
+#define WGL_TEXTURE_FLOAT_R_NV         0x20B5
+#define WGL_TEXTURE_FLOAT_RG_NV        0x20B6
+#define WGL_TEXTURE_FLOAT_RGB_NV       0x20B7
+#define WGL_TEXTURE_FLOAT_RGBA_NV      0x20B8
+#endif
+
+#ifndef WGL_NV_swap_group
+#endif
+
+#ifndef WGL_NV_gpu_affinity
+#define WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0
+#define WGL_ERROR_MISSING_AFFINITY_MASK_NV 0x20D1
+#endif
+
+
+/*************************************************************/
+
+#ifndef WGL_ARB_pbuffer
+DECLARE_HANDLE(HPBUFFERARB);
+#endif
+#ifndef WGL_EXT_pbuffer
+DECLARE_HANDLE(HPBUFFEREXT);
+#endif
+
+#ifndef WGL_NV_gpu_affinity
+DECLARE_HANDLE(HGPUNV);
+typedef struct _GPU_DEVICE
+{
+    DWORD  cb;
+    CHAR   DeviceName[32];
+    CHAR   DeviceString[128];
+    DWORD  Flags;
+    RECT   rcVirtualScreen;
+} GPU_DEVICE, *PGPU_DEVICE;
+#endif
+
+#ifndef WGL_ARB_buffer_region
+#define WGL_ARB_buffer_region 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern HANDLE WINAPI wglCreateBufferRegionARB(HDC, int, UINT);
+extern VOID WINAPI wglDeleteBufferRegionARB(HANDLE);
+extern BOOL WINAPI wglSaveBufferRegionARB(HANDLE, int, int, int, int);
+extern BOOL WINAPI wglRestoreBufferRegionARB(HANDLE, int, int, int, int, int, int);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef HANDLE(WINAPI *PFNWGLCREATEBUFFERREGIONARBPROC)(HDC hDC, int iLayerPlane, UINT uType);
+typedef VOID (WINAPI *PFNWGLDELETEBUFFERREGIONARBPROC)(HANDLE hRegion);
+typedef BOOL (WINAPI *PFNWGLSAVEBUFFERREGIONARBPROC)(HANDLE hRegion, int x, int y, int width, int height);
+typedef BOOL (WINAPI *PFNWGLRESTOREBUFFERREGIONARBPROC)(HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
+#endif
+
+#ifndef WGL_ARB_multisample
+#define WGL_ARB_multisample 1
+#endif
+
+#ifndef WGL_ARB_extensions_string
+#define WGL_ARB_extensions_string 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern const char *WINAPI wglGetExtensionsStringARB(HDC);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef const char *(WINAPI *PFNWGLGETEXTENSIONSSTRINGARBPROC)(HDC hdc);
+#endif
+
+#ifndef WGL_ARB_pixel_format
+#define WGL_ARB_pixel_format 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetPixelFormatAttribivARB(HDC, int, int, UINT, const int *, int *);
+extern BOOL WINAPI wglGetPixelFormatAttribfvARB(HDC, int, int, UINT, const int *, FLOAT *);
+extern BOOL WINAPI wglChoosePixelFormatARB(HDC, const int *, const FLOAT *, UINT, int *, UINT *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBIVARBPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBFVARBPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI *PFNWGLCHOOSEPIXELFORMATARBPROC)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+#endif
+
+#ifndef WGL_ARB_make_current_read
+#define WGL_ARB_make_current_read 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglMakeContextCurrentARB(HDC, HDC, HGLRC);
+extern HDC WINAPI wglGetCurrentReadDCARB(void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLMAKECONTEXTCURRENTARBPROC)(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+typedef HDC(WINAPI *PFNWGLGETCURRENTREADDCARBPROC)(void);
+#endif
+
+#ifndef WGL_ARB_pbuffer
+#define WGL_ARB_pbuffer 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern HPBUFFERARB WINAPI wglCreatePbufferARB(HDC, int, int, int, const int *);
+extern HDC WINAPI wglGetPbufferDCARB(HPBUFFERARB);
+extern int WINAPI wglReleasePbufferDCARB(HPBUFFERARB, HDC);
+extern BOOL WINAPI wglDestroyPbufferARB(HPBUFFERARB);
+extern BOOL WINAPI wglQueryPbufferARB(HPBUFFERARB, int, int *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef HPBUFFERARB(WINAPI *PFNWGLCREATEPBUFFERARBPROC)(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef HDC(WINAPI *PFNWGLGETPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer);
+typedef int (WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer, HDC hDC);
+typedef BOOL (WINAPI *PFNWGLDESTROYPBUFFERARBPROC)(HPBUFFERARB hPbuffer);
+typedef BOOL (WINAPI *PFNWGLQUERYPBUFFERARBPROC)(HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
+#endif
+
+#ifndef WGL_ARB_render_texture
+#define WGL_ARB_render_texture 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglBindTexImageARB(HPBUFFERARB, int);
+extern BOOL WINAPI wglReleaseTexImageARB(HPBUFFERARB, int);
+extern BOOL WINAPI wglSetPbufferAttribARB(HPBUFFERARB, const int *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLBINDTEXIMAGEARBPROC)(HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI *PFNWGLRELEASETEXIMAGEARBPROC)(HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI *PFNWGLSETPBUFFERATTRIBARBPROC)(HPBUFFERARB hPbuffer, const int *piAttribList);
+#endif
+
+#ifndef WGL_ARB_pixel_format_float
+#define WGL_ARB_pixel_format_float 1
+#endif
+
+#ifndef WGL_EXT_display_color_table
+#define WGL_EXT_display_color_table 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern GLboolean WINAPI wglCreateDisplayColorTableEXT(GLushort);
+extern GLboolean WINAPI wglLoadDisplayColorTableEXT(const GLushort *, GLuint);
+extern GLboolean WINAPI wglBindDisplayColorTableEXT(GLushort);
+extern VOID WINAPI wglDestroyDisplayColorTableEXT(GLushort);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef GLboolean(WINAPI *PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+typedef GLboolean(WINAPI *PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)(const GLushort *table, GLuint length);
+typedef GLboolean(WINAPI *PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+typedef VOID (WINAPI *PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+#endif
+
+#ifndef WGL_EXT_extensions_string
+#define WGL_EXT_extensions_string 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern const char *WINAPI wglGetExtensionsStringEXT(void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef const char *(WINAPI *PFNWGLGETEXTENSIONSSTRINGEXTPROC)(void);
+#endif
+
+#ifndef WGL_EXT_make_current_read
+#define WGL_EXT_make_current_read 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglMakeContextCurrentEXT(HDC, HDC, HGLRC);
+extern HDC WINAPI wglGetCurrentReadDCEXT(void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLMAKECONTEXTCURRENTEXTPROC)(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+typedef HDC(WINAPI *PFNWGLGETCURRENTREADDCEXTPROC)(void);
+#endif
+
+#ifndef WGL_EXT_pbuffer
+#define WGL_EXT_pbuffer 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern HPBUFFEREXT WINAPI wglCreatePbufferEXT(HDC, int, int, int, const int *);
+extern HDC WINAPI wglGetPbufferDCEXT(HPBUFFEREXT);
+extern int WINAPI wglReleasePbufferDCEXT(HPBUFFEREXT, HDC);
+extern BOOL WINAPI wglDestroyPbufferEXT(HPBUFFEREXT);
+extern BOOL WINAPI wglQueryPbufferEXT(HPBUFFEREXT, int, int *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef HPBUFFEREXT(WINAPI *PFNWGLCREATEPBUFFEREXTPROC)(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef HDC(WINAPI *PFNWGLGETPBUFFERDCEXTPROC)(HPBUFFEREXT hPbuffer);
+typedef int (WINAPI *PFNWGLRELEASEPBUFFERDCEXTPROC)(HPBUFFEREXT hPbuffer, HDC hDC);
+typedef BOOL (WINAPI *PFNWGLDESTROYPBUFFEREXTPROC)(HPBUFFEREXT hPbuffer);
+typedef BOOL (WINAPI *PFNWGLQUERYPBUFFEREXTPROC)(HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
+#endif
+
+#ifndef WGL_EXT_pixel_format
+#define WGL_EXT_pixel_format 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetPixelFormatAttribivEXT(HDC, int, int, UINT, int *, int *);
+extern BOOL WINAPI wglGetPixelFormatAttribfvEXT(HDC, int, int, UINT, int *, FLOAT *);
+extern BOOL WINAPI wglChoosePixelFormatEXT(HDC, const int *, const FLOAT *, UINT, int *, UINT *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
+typedef BOOL (WINAPI *PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI *PFNWGLCHOOSEPIXELFORMATEXTPROC)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+#endif
+
+#ifndef WGL_EXT_swap_control
+#define WGL_EXT_swap_control 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglSwapIntervalEXT(int);
+extern int WINAPI wglGetSwapIntervalEXT(void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLSWAPINTERVALEXTPROC)(int interval);
+typedef int (WINAPI *PFNWGLGETSWAPINTERVALEXTPROC)(void);
+#endif
+
+#ifndef WGL_EXT_depth_float
+#define WGL_EXT_depth_float 1
+#endif
+
+#ifndef WGL_NV_vertex_array_range
+#define WGL_NV_vertex_array_range 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern void *WINAPI wglAllocateMemoryNV(GLsizei, GLfloat, GLfloat, GLfloat);
+extern void WINAPI wglFreeMemoryNV(void *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef void *(WINAPI *PFNWGLALLOCATEMEMORYNVPROC)(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
+typedef void (WINAPI *PFNWGLFREEMEMORYNVPROC)(void *pointer);
+#endif
+
+#ifndef WGL_3DFX_multisample
+#define WGL_3DFX_multisample 1
+#endif
+
+#ifndef WGL_EXT_multisample
+#define WGL_EXT_multisample 1
+#endif
+
+#ifndef WGL_OML_sync_control
+#define WGL_OML_sync_control 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetSyncValuesOML(HDC, INT64 *, INT64 *, INT64 *);
+extern BOOL WINAPI wglGetMscRateOML(HDC, INT32 *, INT32 *);
+extern INT64 WINAPI wglSwapBuffersMscOML(HDC, INT64, INT64, INT64);
+extern INT64 WINAPI wglSwapLayerBuffersMscOML(HDC, int, INT64, INT64, INT64);
+extern BOOL WINAPI wglWaitForMscOML(HDC, INT64, INT64, INT64, INT64 *, INT64 *, INT64 *);
+extern BOOL WINAPI wglWaitForSbcOML(HDC, INT64, INT64 *, INT64 *, INT64 *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETSYNCVALUESOMLPROC)(HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef BOOL (WINAPI *PFNWGLGETMSCRATEOMLPROC)(HDC hdc, INT32 *numerator, INT32 *denominator);
+typedef INT64(WINAPI *PFNWGLSWAPBUFFERSMSCOMLPROC)(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef INT64(WINAPI *PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)(HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef BOOL (WINAPI *PFNWGLWAITFORMSCOMLPROC)(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef BOOL (WINAPI *PFNWGLWAITFORSBCOMLPROC)(HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
+#endif
+
+#ifndef WGL_I3D_digital_video_control
+#define WGL_I3D_digital_video_control 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetDigitalVideoParametersI3D(HDC, int, int *);
+extern BOOL WINAPI wglSetDigitalVideoParametersI3D(HDC, int, const int *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)(HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (WINAPI *PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)(HDC hDC, int iAttribute, const int *piValue);
+#endif
+
+#ifndef WGL_I3D_gamma
+#define WGL_I3D_gamma 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetGammaTableParametersI3D(HDC, int, int *);
+extern BOOL WINAPI wglSetGammaTableParametersI3D(HDC, int, const int *);
+extern BOOL WINAPI wglGetGammaTableI3D(HDC, int, USHORT *, USHORT *, USHORT *);
+extern BOOL WINAPI wglSetGammaTableI3D(HDC, int, const USHORT *, const USHORT *, const USHORT *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)(HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (WINAPI *PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)(HDC hDC, int iAttribute, const int *piValue);
+typedef BOOL (WINAPI *PFNWGLGETGAMMATABLEI3DPROC)(HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
+typedef BOOL (WINAPI *PFNWGLSETGAMMATABLEI3DPROC)(HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
+#endif
+
+#ifndef WGL_I3D_genlock
+#define WGL_I3D_genlock 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglEnableGenlockI3D(HDC);
+extern BOOL WINAPI wglDisableGenlockI3D(HDC);
+extern BOOL WINAPI wglIsEnabledGenlockI3D(HDC, BOOL *);
+extern BOOL WINAPI wglGenlockSourceI3D(HDC, UINT);
+extern BOOL WINAPI wglGetGenlockSourceI3D(HDC, UINT *);
+extern BOOL WINAPI wglGenlockSourceEdgeI3D(HDC, UINT);
+extern BOOL WINAPI wglGetGenlockSourceEdgeI3D(HDC, UINT *);
+extern BOOL WINAPI wglGenlockSampleRateI3D(HDC, UINT);
+extern BOOL WINAPI wglGetGenlockSampleRateI3D(HDC, UINT *);
+extern BOOL WINAPI wglGenlockSourceDelayI3D(HDC, UINT);
+extern BOOL WINAPI wglGetGenlockSourceDelayI3D(HDC, UINT *);
+extern BOOL WINAPI wglQueryGenlockMaxSourceDelayI3D(HDC, UINT *, UINT *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLENABLEGENLOCKI3DPROC)(HDC hDC);
+typedef BOOL (WINAPI *PFNWGLDISABLEGENLOCKI3DPROC)(HDC hDC);
+typedef BOOL (WINAPI *PFNWGLISENABLEDGENLOCKI3DPROC)(HDC hDC, BOOL *pFlag);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEI3DPROC)(HDC hDC, UINT uSource);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEI3DPROC)(HDC hDC, UINT *uSource);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEEDGEI3DPROC)(HDC hDC, UINT uEdge);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)(HDC hDC, UINT *uEdge);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSAMPLERATEI3DPROC)(HDC hDC, UINT uRate);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSAMPLERATEI3DPROC)(HDC hDC, UINT *uRate);
+typedef BOOL (WINAPI *PFNWGLGENLOCKSOURCEDELAYI3DPROC)(HDC hDC, UINT uDelay);
+typedef BOOL (WINAPI *PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)(HDC hDC, UINT *uDelay);
+typedef BOOL (WINAPI *PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)(HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
+#endif
+
+#ifndef WGL_I3D_image_buffer
+#define WGL_I3D_image_buffer 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern LPVOID WINAPI wglCreateImageBufferI3D(HDC, DWORD, UINT);
+extern BOOL WINAPI wglDestroyImageBufferI3D(HDC, LPVOID);
+extern BOOL WINAPI wglAssociateImageBufferEventsI3D(HDC, const HANDLE *, const LPVOID *, const DWORD *, UINT);
+extern BOOL WINAPI wglReleaseImageBufferEventsI3D(HDC, const LPVOID *, UINT);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef LPVOID (WINAPI *PFNWGLCREATEIMAGEBUFFERI3DPROC)(HDC hDC, DWORD dwSize, UINT uFlags);
+typedef BOOL (WINAPI *PFNWGLDESTROYIMAGEBUFFERI3DPROC)(HDC hDC, LPVOID pAddress);
+typedef BOOL (WINAPI *PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)(HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count);
+typedef BOOL (WINAPI *PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)(HDC hDC, const LPVOID *pAddress, UINT count);
+#endif
+
+#ifndef WGL_I3D_swap_frame_lock
+#define WGL_I3D_swap_frame_lock 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglEnableFrameLockI3D(void);
+extern BOOL WINAPI wglDisableFrameLockI3D(void);
+extern BOOL WINAPI wglIsEnabledFrameLockI3D(BOOL *);
+extern BOOL WINAPI wglQueryFrameLockMasterI3D(BOOL *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLENABLEFRAMELOCKI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLDISABLEFRAMELOCKI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLISENABLEDFRAMELOCKI3DPROC)(BOOL *pFlag);
+typedef BOOL (WINAPI *PFNWGLQUERYFRAMELOCKMASTERI3DPROC)(BOOL *pFlag);
+#endif
+
+#ifndef WGL_I3D_swap_frame_usage
+#define WGL_I3D_swap_frame_usage 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetFrameUsageI3D(float *);
+extern BOOL WINAPI wglBeginFrameTrackingI3D(void);
+extern BOOL WINAPI wglEndFrameTrackingI3D(void);
+extern BOOL WINAPI wglQueryFrameTrackingI3D(DWORD *, DWORD *, float *);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLGETFRAMEUSAGEI3DPROC)(float *pUsage);
+typedef BOOL (WINAPI *PFNWGLBEGINFRAMETRACKINGI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLENDFRAMETRACKINGI3DPROC)(void);
+typedef BOOL (WINAPI *PFNWGLQUERYFRAMETRACKINGI3DPROC)(DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
+#endif
+
+#ifndef WGL_ATI_pixel_format_float
+#define WGL_ATI_pixel_format_float 1
+#endif
+
+#ifndef WGL_NV_render_depth_texture
+#define WGL_NV_render_depth_texture 1
+#endif
+
+#ifndef WGL_NV_render_texture_rectangle
+#define WGL_NV_render_texture_rectangle 1
+#endif
+
+#ifndef WGL_NV_float_buffer
+#define WGL_NV_float_buffer 1
+#endif
+
+#ifndef WGL_NV_swap_group
+#define WGL_NV_swap_group 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglJoinSwapGroupNV(HDC hDC, GLuint group);
+extern BOOL WINAPI wglBindSwapBarrierNV(GLuint group, GLuint barrier);
+extern BOOL WINAPI wglQuerySwapGroupNV(HDC hDC, GLuint *group, GLuint *barrier);
+extern BOOL WINAPI wglQueryMaxSwapGroupsNV(HDC hDC, GLuint *maxGroups, GLuint *maxBarriers);
+extern BOOL WINAPI wglQueryFrameCountNV(HDC hDC, GLuint *count);
+extern BOOL WINAPI wglResetFrameCountNV(HDC hDC);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI *PFNWGLJOINSWAPGROUPNVPROC)(HDC hDC, GLuint group);
+typedef BOOL (WINAPI *PFNWGLBINDSWAPBARRIERNVPROC)(GLuint group, GLuint barrier);
+typedef BOOL (WINAPI *PFNWGLQUERYSWAPGROUPNVPROC)(HDC hDC, GLuint *group, GLuint *barrier);
+typedef BOOL (WINAPI *PFNWGLQUERYMAXSWAPGROUPSNVPROC)(HDC hDC, GLuint *maxGroups, GLuint *maxBarriers);
+typedef BOOL (WINAPI *PFNWGLQUERYFRAMECOUNTNVPROC)(HDC hDC, GLuint *count);
+typedef BOOL (WINAPI *PFNWGLRESETFRAMECOUNTNVPROC)(HDC hDC);
+#endif
+
+#ifndef WGL_NV_gpu_affinity
+#define WGL_NV_gpu_affinity 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglEnumGpusNV(UINT iIndex, HGPUNV *hGpu);
+extern BOOL WINAPI wglEnumGpuDevicesNV(HGPUNV hGpu, UINT iIndex, PGPU_DEVICE pGpuDevice);
+extern HDC WINAPI wglCreateAffinityDCNV(const HGPUNV *pGpuList);
+extern BOOL WINAPI wglEnumGpusFromAffinityDCNV(HDC hAffinityDC, UINT iIndex, HGPUNV *hGpu);
+extern BOOL WINAPI wglDeleteDCNV(HDC hAffinityDC);
+#else
+typedef BOOL (WINAPI *PFNWGLENUMGPUSNVPROC)(UINT iIndex, HGPUNV *hGpu);
+typedef BOOL (WINAPI *PFNWGLENUMGPUDEVICESNVPROC)(HGPUNV hGpu, UINT iIndex, PGPU_DEVICE pGpuDevice);
+typedef HDC(WINAPI *PFNWGLCREATEAFFINITYDCNVPROC)(const HGPUNV *pGpuList);
+typedef BOOL (WINAPI *PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)(HDC hAffinityDC, UINT iIndex, HGPUNV *hGpu);
+typedef BOOL (WINAPI *PFNWGLDELETEDCNVPROC)(HDC hAffinityDC);
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Common/UtilNPP/Exceptions.h

@@ -0,0 +1,197 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef NV_UTIL_NPP_EXCEPTIONS_H
+#define NV_UTIL_NPP_EXCEPTIONS_H
+
+
+#include <string>
+#include <sstream>
+#include <iostream>
+
+/// All npp related C++ classes are put into the npp namespace.
+namespace npp
+{
+
+    /// Exception base class.
+    ///     This exception base class will be used for everything C++ throught
+    /// the NPP project.
+    ///     The exception contains a string message, as well as data fields for a string
+    /// containing the name of the file as well as the line number where the exception was thrown.
+    ///     The easiest way of throwing exceptions and providing filename and line number is
+    /// to use one of the ASSERT macros defined for that purpose.
+    class Exception
+    {
+        public:
+            /// Constructor.
+            /// \param rMessage A message with information as to why the exception was thrown.
+            /// \param rFileName The name of the file where the exception was thrown.
+            /// \param nLineNumber Line number in the file where the exception was thrown.
+            explicit
+            Exception(const std::string &rMessage = "", const std::string &rFileName = "", unsigned int nLineNumber = 0)
+                : sMessage_(rMessage), sFileName_(rFileName), nLineNumber_(nLineNumber)
+            { };
+
+            Exception(const Exception &rException)
+                : sMessage_(rException.sMessage_), sFileName_(rException.sFileName_), nLineNumber_(rException.nLineNumber_)
+            { };
+
+            virtual
+            ~Exception()
+            { };
+
+            /// Get the exception's message.
+            const
+            std::string &
+            message()
+            const
+            {
+                return sMessage_;
+            }
+
+            /// Get the exception's file info.
+            const
+            std::string &
+            fileName()
+            const
+            {
+                return sFileName_;
+            }
+
+            /// Get the exceptions's line info.
+            unsigned int
+            lineNumber()
+            const
+            {
+                return nLineNumber_;
+            }
+
+
+            /// Create a clone of this exception.
+            ///      This creates a new Exception object on the heap. It is
+            /// the responsibility of the user of this function to free this memory
+            /// (delete x).
+            virtual
+            Exception *
+            clone()
+            const
+            {
+                return new Exception(*this);
+            }
+
+            /// Create a single string with all the exceptions information.
+            ///     The virtual toString() method is used by the operator<<()
+            /// so that all exceptions derived from this base-class can print
+            /// their full information correctly even if a reference to their
+            /// exact type is not had at the time of printing (i.e. the basic
+            /// operator<<() is used).
+            virtual
+            std::string
+            toString()
+            const
+            {
+                std::ostringstream oOutputString;
+                oOutputString << fileName() << ":" << lineNumber() << ": " << message();
+                return oOutputString.str();
+            }
+
+        private:
+            std::string sMessage_;      ///< Message regarding the cause of the exception.
+            std::string sFileName_;     ///< Name of the file where the exception was thrown.
+            unsigned int nLineNumber_;  ///< Line number in the file where the exception was thrown
+    };
+
+    /// Output stream inserter for Exception.
+    /// \param rOutputStream The stream the exception information is written to.
+    /// \param rException The exception that's being written.
+    /// \return Reference to the output stream being used.
+    std::ostream &
+    operator << (std::ostream &rOutputStream, const Exception &rException)
+    {
+        rOutputStream << rException.toString();
+        return rOutputStream;
+    }
+
+    /// Basic assert macro.
+    ///     This macro should be used to enforce any kind of pre or post conditions.
+    /// Unlike the C-runtime assert macro, this macro does not abort execution, but throws
+    /// a C++ exception. The exception is automatically filled with information about the failing
+    /// condition, the filename and line number where the exception was thrown.
+    /// \note The macro is written in such a way that omitting a semicolon after its usage
+    ///     causes a compiler error. The correct way to invoke this macro is:
+    /// NPP_ASSERT(n < MAX);
+#define NPP_ASSERT(C) do {if (!(C)) throw npp::Exception(#C " assertion faild!", __FILE__, __LINE__);} while(false)
+
+    // ASSERT macro.
+    //  Same functionality as the basic assert macro with the added ability to pass
+    //  a message M. M should be a string literal.
+    //  Note: Never use code inside ASSERT() that causes a side-effect ASSERT macros may get compiled
+    //      out in release mode.
+#define NPP_ASSERT_MSG(C, M) do {if (!(C)) throw npp::Exception(#C " assertion faild! Message: " M, __FILE__, __LINE__);} while(false)
+
+#ifdef _DEBUG
+    /// Basic debug assert macro.
+    ///     This macro is identical in every respect to NPP_ASSERT(C) but it does get compiled to a
+    /// no-op in release builds. It is therefor of utmost importance to not put statements into
+    /// this macro that cause side effects required for correct program execution.
+#define NPP_DEBUG_ASSERT(C) do {if (!(C)) throw npp::Exception(#C " debug assertion faild!", __FILE__, __LINE__);} while(false)
+#else
+#define NPP_DEBUG_ASSERT(C)
+#endif
+
+    /// ASSERT for null-pointer test.
+    /// It is safe to put code with side effects into this macro. Also: This macro never
+    /// gets compiled to a no-op because resource allocation may fail based on external causes not under
+    /// control of a software developer.
+#define NPP_ASSERT_NOT_NULL(P) do {if ((P) == 0) throw npp::Exception(#P " not null assertion faild!", __FILE__, __LINE__);} while(false)
+
+    /// Macro for flagging methods as not implemented.
+    /// The macro throws an exception with a message that an implementation was missing
+#define NPP_NOT_IMPLEMENTED() do {throw npp::Exception("Implementation missing!", __FILE__, __LINE__);} while(false)
+
+    /// Macro for checking error return code of CUDA (runtime) calls.
+    /// This macro never gets disabled.
+#define NPP_CHECK_CUDA(S) do {cudaError_t eCUDAResult; \
+        eCUDAResult = S; \
+        if (eCUDAResult != cudaSuccess) std::cout << "NPP_CHECK_CUDA - eCUDAResult = " << eCUDAResult << std::endl; \
+        NPP_ASSERT(eCUDAResult == cudaSuccess);} while (false)
+
+    /// Macro for checking error return code for NPP calls.
+#define NPP_CHECK_NPP(S) do {NppStatus eStatusNPP; \
+        eStatusNPP = S; \
+        if (eStatusNPP != NPP_SUCCESS) std::cout << "NPP_CHECK_NPP - eStatusNPP = " << _cudaGetErrorEnum(eStatusNPP) << "("<< eStatusNPP << ")" << std::endl; \
+        NPP_ASSERT(eStatusNPP == NPP_SUCCESS);} while (false)
+
+    /// Macro for checking error return codes from cuFFT calls.
+#define NPP_CHECK_CUFFT(S) do {cufftResult eCUFFTResult; \
+        eCUFFTResult = S; \
+        if (eCUFFTResult != NPP_SUCCESS) std::cout << "NPP_CHECK_CUFFT - eCUFFTResult = " << eCUFFTResult << std::endl; \
+        NPP_ASSERT(eCUFFTResult == CUFFT_SUCCESS);} while (false)
+
+} // npp namespace
+
+#endif // NV_UTIL_NPP_EXCEPTIONS_H

Common/UtilNPP/Image.h

@@ -0,0 +1,155 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef NV_UTIL_NPP_IMAGE_H
+#define NV_UTIL_NPP_IMAGE_H
+
+#include <cstddef>
+
+namespace npp
+{
+
+    class Image
+    {
+        public:
+            struct Size
+            {
+                unsigned int nWidth;
+                unsigned int nHeight;
+
+                Size() : nWidth(0), nHeight(0)
+                { };
+
+                Size(unsigned int nWidthNew, unsigned nHeightNew) : nWidth(nWidthNew), nHeight(nHeightNew)
+                { };
+
+                Size(const Size &rSize) : nWidth(rSize.nWidth), nHeight(rSize.nHeight)
+                { };
+
+                Size &
+                operator= (const Size &rSize)
+                {
+                    if (&rSize == this)
+                    {
+                        return *this;
+                    }
+
+                    nWidth = rSize.nWidth;
+                    nHeight = rSize.nHeight;
+
+                    return *this;
+                }
+
+                void
+                swap(Size &rSize)
+                {
+                    unsigned int nTemp;
+                    nTemp = nWidth;
+                    nWidth = rSize.nWidth;
+                    rSize.nWidth = nTemp;
+
+                    nTemp = nHeight;
+                    nHeight = rSize.nHeight;
+                    rSize.nHeight = nTemp;
+                }
+            };
+
+            Image()
+            { };
+
+            Image(unsigned int nWidth, unsigned int nHeight) : oSize_(nWidth, nHeight)
+            { };
+
+            Image(const Image::Size &rSize) : oSize_(rSize)
+            { };
+
+            Image(const Image &rImage) : oSize_(rImage.oSize_)
+            { };
+
+            virtual
+            ~Image()
+            { };
+
+            Image &
+            operator= (const Image &rImage)
+            {
+                if (&rImage == this)
+                {
+                    return *this;
+                }
+
+                oSize_  = rImage.oSize_;
+                return *this;
+            };
+
+            unsigned int
+            width()
+            const
+            {
+                return oSize_.nWidth;
+            }
+
+            unsigned int
+            height()
+            const
+            {
+                return oSize_.nHeight;
+            }
+
+            Size
+            size()
+            const
+            {
+                return oSize_;
+            }
+
+            void
+            swap(Image &rImage)
+            {
+                oSize_.swap(rImage.oSize_);
+            }
+
+        private:
+            Size oSize_;
+    };
+
+    bool
+    operator== (const Image::Size &rFirst, const Image::Size &rSecond)
+    {
+        return rFirst.nWidth == rSecond.nWidth && rFirst.nHeight == rSecond.nHeight;
+    }
+
+    bool
+    operator!= (const Image::Size &rFirst, const Image::Size &rSecond)
+    {
+        return rFirst.nWidth != rSecond.nWidth || rFirst.nHeight != rSecond.nHeight;
+    }
+
+} // npp namespace
+
+
+#endif // NV_UTIL_NPP_IMAGE_H

Common/UtilNPP/ImageAllocatorsCPU.h

@@ -0,0 +1,80 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef NV_UTIL_NPP_IMAGE_ALLOCATORS_CPU_H
+#define NV_UTIL_NPP_IMAGE_ALLOCATORS_CPU_H
+
+#include "Exceptions.h"
+
+namespace npp
+{
+
+    template <typename D, size_t N>
+    class ImageAllocatorCPU
+    {
+        public:
+            static
+            D *
+            Malloc2D(unsigned int nWidth, unsigned int nHeight, unsigned int *pPitch)
+            {
+                NPP_ASSERT(nWidth * nHeight > 0);
+
+                D *pResult = new D[nWidth * N * nHeight];
+                *pPitch = nWidth * sizeof(D) * N;
+
+                return pResult;
+            };
+
+            static
+            void
+            Free2D(D *pPixels)
+            {
+                delete[] pPixels;
+            };
+
+            static
+            void
+            Copy2D(D *pDst, size_t nDstPitch, const D *pSrc, size_t nSrcPitch, size_t nWidth, size_t nHeight)
+            {
+                const void *pSrcLine = pSrc;
+                void        *pDstLine = pDst;
+
+                for (size_t iLine = 0; iLine < nHeight; ++iLine)
+                {
+                    // copy one line worth of data
+                    memcpy(pDst, pSrc, nWidth * N * sizeof(D));
+                    // move data pointers to next line
+                    pDst += nDstPitch;
+                    pSrc += nSrcPitch;
+                }
+            };
+
+    };
+
+} // npp namespace
+
+#endif // NV_UTIL_NPP_IMAGE_ALLOCATORS_CPU_H

Common/UtilNPP/ImageIO.h

@@ -0,0 +1,149 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef NV_UTIL_NPP_IMAGE_IO_H
+#define NV_UTIL_NPP_IMAGE_IO_H
+
+#include "ImagesCPU.h"
+#include "ImagesNPP.h"
+
+#include "FreeImage.h"
+#include "Exceptions.h"
+
+#include <string>
+#include "string.h"
+
+
+// Error handler for FreeImage library.
+//  In case this handler is invoked, it throws an NPP exception.
+void
+FreeImageErrorHandler(FREE_IMAGE_FORMAT oFif, const char *zMessage)
+{
+    throw npp::Exception(zMessage);
+}
+
+namespace npp
+{
+    // Load a gray-scale image from disk.
+    void
+    loadImage(const std::string &rFileName, ImageCPU_8u_C1 &rImage)
+    {
+        // set your own FreeImage error handler
+        FreeImage_SetOutputMessage(FreeImageErrorHandler);
+
+        FREE_IMAGE_FORMAT eFormat = FreeImage_GetFileType(rFileName.c_str());
+
+        // no signature? try to guess the file format from the file extension
+        if (eFormat == FIF_UNKNOWN)
+        {
+            eFormat = FreeImage_GetFIFFromFilename(rFileName.c_str());
+        }
+
+        NPP_ASSERT(eFormat != FIF_UNKNOWN);
+        // check that the plugin has reading capabilities ...
+        FIBITMAP *pBitmap;
+
+        if (FreeImage_FIFSupportsReading(eFormat))
+        {
+            pBitmap = FreeImage_Load(eFormat, rFileName.c_str());
+        }
+
+        NPP_ASSERT(pBitmap != 0);
+        // make sure this is an 8-bit single channel image
+        NPP_ASSERT(FreeImage_GetColorType(pBitmap) == FIC_MINISBLACK);
+        NPP_ASSERT(FreeImage_GetBPP(pBitmap) == 8);
+
+        // create an ImageCPU to receive the loaded image data
+        ImageCPU_8u_C1 oImage(FreeImage_GetWidth(pBitmap), FreeImage_GetHeight(pBitmap));
+
+        // Copy the FreeImage data into the new ImageCPU
+        unsigned int nSrcPitch = FreeImage_GetPitch(pBitmap);
+        const Npp8u *pSrcLine = FreeImage_GetBits(pBitmap) + nSrcPitch * (FreeImage_GetHeight(pBitmap) -1);
+        Npp8u *pDstLine = oImage.data();
+        unsigned int nDstPitch = oImage.pitch();
+
+        for (size_t iLine = 0; iLine < oImage.height(); ++iLine)
+        {
+            memcpy(pDstLine, pSrcLine, oImage.width() * sizeof(Npp8u));
+            pSrcLine -= nSrcPitch;
+            pDstLine += nDstPitch;
+        }
+
+        // swap the user given image with our result image, effecively
+        // moving our newly loaded image data into the user provided shell
+        oImage.swap(rImage);
+    }
+
+    // Save an gray-scale image to disk.
+    void
+    saveImage(const std::string &rFileName, const ImageCPU_8u_C1 &rImage)
+    {
+        // create the result image storage using FreeImage so we can easily
+        // save
+        FIBITMAP *pResultBitmap = FreeImage_Allocate(rImage.width(), rImage.height(), 8 /* bits per pixel */);
+        NPP_ASSERT_NOT_NULL(pResultBitmap);
+        unsigned int nDstPitch   = FreeImage_GetPitch(pResultBitmap);
+        Npp8u *pDstLine = FreeImage_GetBits(pResultBitmap) + nDstPitch * (rImage.height()-1);
+        const Npp8u *pSrcLine = rImage.data();
+        unsigned int nSrcPitch = rImage.pitch();
+
+        for (size_t iLine = 0; iLine < rImage.height(); ++iLine)
+        {
+            memcpy(pDstLine, pSrcLine, rImage.width() * sizeof(Npp8u));
+            pSrcLine += nSrcPitch;
+            pDstLine -= nDstPitch;
+        }
+
+        // now save the result image
+        bool bSuccess;
+        bSuccess = FreeImage_Save(FIF_PGM, pResultBitmap, rFileName.c_str(), 0) == TRUE;
+        NPP_ASSERT_MSG(bSuccess, "Failed to save result image.");
+    }
+
+    // Load a gray-scale image from disk.
+    void
+    loadImage(const std::string &rFileName, ImageNPP_8u_C1 &rImage)
+    {
+        ImageCPU_8u_C1 oImage;
+        loadImage(rFileName, oImage);
+        ImageNPP_8u_C1 oResult(oImage);
+        rImage.swap(oResult);
+    }
+
+    // Save an gray-scale image to disk.
+    void
+    saveImage(const std::string &rFileName, const ImageNPP_8u_C1 &rImage)
+    {
+        ImageCPU_8u_C1 oHostImage(rImage.size());
+        // copy the device result data
+        rImage.copyTo(oHostImage.data(), oHostImage.pitch());
+        saveImage(rFileName, oHostImage);
+    }
+}
+
+
+#endif // NV_UTIL_NPP_IMAGE_IO_H

Common/UtilNPP/ImagePacked.h

@@ -0,0 +1,171 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef NV_UTIL_NPP_IMAGE_PACKED_H
+#define NV_UTIL_NPP_IMAGE_PACKED_H
+
+#include "Image.h"
+#include "Pixel.h"
+
+namespace npp
+{
+    template<typename D, size_t N, class A>
+    class ImagePacked: public npp::Image
+    {
+        public:
+            typedef npp::Pixel<D, N>    tPixel;
+            typedef D                   tData;
+            static const size_t         gnChannels = N;
+            typedef npp::Image::Size    tSize;
+
+            ImagePacked(): aPixels_(0)
+                , nPitch_(0)
+            {
+                ;
+            }
+
+            ImagePacked(unsigned int nWidth, unsigned int nHeight): Image(nWidth, nHeight)
+                , aPixels_(0)
+                , nPitch_(0)
+            {
+                aPixels_ = A::Malloc2D(width(), height(), &nPitch_);
+            }
+
+            ImagePacked(unsigned int nWidth, unsigned int nHeight, bool bTight): Image(nWidth, nHeight)
+                , aPixels_(0)
+                , nPitch_(0)
+            {
+                aPixels_ = A::Malloc2D(width(), height(), &nPitch_, bTight);
+            }
+
+            ImagePacked(const tSize &rSize): Image(rSize)
+                , aPixels_(0)
+                , nPitch_(0)
+            {
+                aPixels_ = A::Malloc2D(width(), height(), &nPitch_);
+            }
+
+            ImagePacked(const ImagePacked<D, N, A> &rImage): Image(rImage)
+                , aPixels_(0)
+                , nPitch_(rImage.pitch())
+            {
+                aPixels_ = A::Malloc2D(width(), height(), &nPitch_);
+                A::Copy2D(aPixels_, nPitch_, rImage.pixels(), rImage.pitch(), width(), height());
+            }
+
+            virtual
+            ~ImagePacked()
+            {
+                A::Free2D(aPixels_);
+            }
+
+            ImagePacked &
+            operator= (const ImagePacked<D, N, A> &rImage)
+            {
+                // in case of self-assignment
+                if (&rImage == this)
+                {
+                    return *this;
+                }
+
+                A::Free2D(aPixels_);
+                aPixels_ = 0;
+                nPitch_ = 0;
+
+                // assign parent class's data fields (width, height)
+                Image::operator =(rImage);
+
+                aPixels_ = A::Malloc2D(width(), height(), &nPitch_);
+                A::Copy2D(aPixels_, nPitch_, rImage.data(), rImage.pitch(), width(), height());
+
+                return *this;
+            }
+
+            unsigned int
+            pitch()
+            const
+            {
+                return nPitch_;
+            }
+
+            /// Get a pointer to the pixel array.
+            ///     The result pointer can be offset to pixel at position (x, y) and
+            /// even negative offsets are allowed.
+            /// \param nX Horizontal pointer/array offset.
+            /// \param nY Vertical pointer/array offset.
+            /// \return Pointer to the pixel array (or first pixel in array with coordinates (nX, nY).
+            tPixel *
+            pixels(int nX = 0, int nY = 0)
+            {
+                return reinterpret_cast<tPixel *>(reinterpret_cast<unsigned char *>(aPixels_) + nY * pitch() + nX * gnChannels * sizeof(D));
+            }
+
+            const
+            tPixel *
+            pixels(int nX = 0, int nY = 0)
+            const
+            {
+                return reinterpret_cast<const tPixel *>(reinterpret_cast<unsigned char *>(aPixels_) + nY * pitch() + nX * gnChannels * sizeof(D));
+            }
+
+            D *
+            data(int nX = 0, int nY = 0)
+            {
+                return reinterpret_cast<D *>(pixels(nX, nY));
+            }
+
+            const
+            D *
+            data(int nX = 0, int nY = 0)
+            const
+            {
+                return reinterpret_cast<const D *>(pixels(nX, nY));
+            }
+
+            void
+            swap(ImagePacked<D, N, A> &rImage)
+            {
+                Image::swap(rImage);
+
+                tData *aTemp   = aPixels_;
+                aPixels_        = rImage.aPixels_;
+                rImage.aPixels_ = aTemp;
+
+                unsigned int nTemp = nPitch_;
+                nPitch_            = rImage.nPitch_;
+                rImage.nPitch_     = nTemp;
+            }
+
+        private:
+            D *aPixels_;
+            unsigned int nPitch_;
+    };
+
+} // npp namespace
+
+
+#endif // NV_IMAGE_IPP_H

Common/UtilNPP/ImagesCPU.h

@@ -0,0 +1,121 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef NV_UTIL_NPP_IMAGES_CPU_H
+#define NV_UTIL_NPP_IMAGES_CPU_H
+
+#include "ImagePacked.h"
+
+#include "ImageAllocatorsCPU.h"
+#include "Exceptions.h"
+
+#include <npp.h>
+
+
+namespace npp
+{
+
+    template<typename D, unsigned int N, class A>
+    class ImageCPU: public npp::ImagePacked<D, N, A>
+    {
+        public:
+
+            ImageCPU()
+            {
+                ;
+            }
+
+            ImageCPU(unsigned int nWidth, unsigned int nHeight): ImagePacked<D, N, A>(nWidth, nHeight)
+            {
+                ;
+            }
+
+            explicit
+            ImageCPU(const npp::Image::Size &rSize): ImagePacked<D, N, A>(rSize)
+            {
+                ;
+            }
+
+            ImageCPU(const ImageCPU<D, N, A> &rImage): Image(rImage)
+            {
+                ;
+            }
+
+            virtual
+            ~ImageCPU()
+            {
+                ;
+            }
+
+            ImageCPU &
+            operator= (const ImageCPU<D, N, A> &rImage)
+            {
+                ImagePacked<D, N, A>::operator= (rImage);
+
+                return *this;
+            }
+
+            npp::Pixel<D, N> &
+            operator()(unsigned int iX, unsigned int iY)
+            {
+                return *ImagePacked<D, N, A>::pixels(iX, iY);
+            }
+
+            npp::Pixel<D, N>
+            operator()(unsigned int iX, unsigned int iY)
+            const
+            {
+                return *ImagePacked<D, N, A>::pixels(iX, iY);
+            }
+
+    };
+
+
+    typedef ImageCPU<Npp8u,  1, npp::ImageAllocatorCPU<Npp8u,      1>  >   ImageCPU_8u_C1;
+    typedef ImageCPU<Npp8u,  2, npp::ImageAllocatorCPU<Npp8u,      2>  >   ImageCPU_8u_C2;
+    typedef ImageCPU<Npp8u,  3, npp::ImageAllocatorCPU<Npp8u,      3>  >   ImageCPU_8u_C3;
+    typedef ImageCPU<Npp8u,  4, npp::ImageAllocatorCPU<Npp8u,      4>  >   ImageCPU_8u_C4;
+
+    typedef ImageCPU<Npp16u, 1, npp::ImageAllocatorCPU<Npp16u,     1>  >   ImageCPU_16u_C1;
+    typedef ImageCPU<Npp16u, 3, npp::ImageAllocatorCPU<Npp16u,     3>  >   ImageCPU_16u_C3;
+    typedef ImageCPU<Npp16u, 4, npp::ImageAllocatorCPU<Npp16u,     4>  >   ImageCPU_16u_C4;
+
+    typedef ImageCPU<Npp16s, 1, npp::ImageAllocatorCPU<Npp16s,     1>  >   ImageCPU_16s_C1;
+    typedef ImageCPU<Npp16s, 3, npp::ImageAllocatorCPU<Npp16s,     3>  >   ImageCPU_16s_C3;
+    typedef ImageCPU<Npp16s, 4, npp::ImageAllocatorCPU<Npp16s,     4>  >   ImageCPU_16s_C4;
+
+    typedef ImageCPU<Npp32s, 1, npp::ImageAllocatorCPU<Npp32s,     1>  >   ImageCPU_32s_C1;
+    typedef ImageCPU<Npp32s, 3, npp::ImageAllocatorCPU<Npp32s,     3>  >   ImageCPU_32s_C3;
+    typedef ImageCPU<Npp32s, 4, npp::ImageAllocatorCPU<Npp32s,     4>  >   ImageCPU_32s_C4;
+
+    typedef ImageCPU<Npp32f, 1, npp::ImageAllocatorCPU<Npp32f,     1>  >   ImageCPU_32f_C1;
+    typedef ImageCPU<Npp32f, 3, npp::ImageAllocatorCPU<Npp32f,     3>  >   ImageCPU_32f_C3;
+    typedef ImageCPU<Npp32f, 4, npp::ImageAllocatorCPU<Npp32f,     4>  >   ImageCPU_32f_C4;
+
+} // npp namespace
+
+#endif // NV_IMAGE_IPP_H

Common/UtilNPP/ImagesNPP.h

@@ -0,0 +1,149 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef NV_UTIL_NPP_IMAGES_NPP_H
+#define NV_UTIL_NPP_IMAGES_NPP_H
+
+#include "Exceptions.h"
+#include "ImagePacked.h"
+
+#include "ImageAllocatorsNPP.h"
+#include <cuda_runtime.h>
+
+namespace npp
+{
+    // forward declaration
+    template<typename D, unsigned int N, class A> class ImageCPU;
+
+    template<typename D, unsigned int N>
+    class ImageNPP: public npp::ImagePacked<D, N, npp::ImageAllocator<D, N> >
+    {
+        public:
+            ImageNPP()
+            {
+                ;
+            }
+
+            ImageNPP(unsigned int nWidth, unsigned int nHeight, bool bTight = false): ImagePacked<D, N, npp::ImageAllocator<D, N> >(nWidth, nHeight, bTight)
+            {
+                ;
+            }
+
+            ImageNPP(const npp::Image::Size &rSize): ImagePacked<D, N, npp::ImageAllocator<D, N> >(rSize)
+            {
+                ;
+            }
+
+            ImageNPP(const ImageNPP<D, N> &rImage): Image(rImage)
+            {
+                ;
+            }
+
+            template<class X>
+            explicit
+            ImageNPP(const ImageCPU<D, N, X> &rImage, bool bTight = false): ImagePacked<D, N, npp::ImageAllocator<D, N> >(rImage.width(), rImage.height(), bTight)
+            {
+                npp::ImageAllocator<D, N>::HostToDeviceCopy2D(ImagePacked<D, N, npp::ImageAllocator<D, N> >::data(),
+                                                              ImagePacked<D, N, npp::ImageAllocator<D, N> >::pitch(),
+                                                              rImage.data(),
+                                                              rImage.pitch(),
+                                                              ImagePacked<D, N, npp::ImageAllocator<D, N> >::width(),
+                                                              ImagePacked<D, N, npp::ImageAllocator<D, N> >::height());
+            }
+
+            virtual
+            ~ImageNPP()
+            {
+                ;
+            }
+
+            ImageNPP &
+            operator= (const ImageNPP<D, N> &rImage)
+            {
+                ImagePacked<D, N, npp::ImageAllocator<D, N> >::operator= (rImage);
+
+                return *this;
+            }
+
+            void
+            copyTo(D *pData, unsigned int nPitch)
+            const
+            {
+                NPP_ASSERT((ImagePacked<D, N, npp::ImageAllocator<D, N> >::width() * sizeof(npp::Pixel<D, N>) <= nPitch));
+                npp::ImageAllocator<D, N>::DeviceToHostCopy2D(pData,
+                                                              nPitch,
+                                                              ImagePacked<D, N, npp::ImageAllocator<D, N> >::data(),
+                                                              ImagePacked<D, N, npp::ImageAllocator<D, N> >::pitch(),
+                                                              ImagePacked<D, N, npp::ImageAllocator<D, N> >::width(),
+                                                              ImagePacked<D, N, npp::ImageAllocator<D, N> >::height());
+            }
+
+            void
+            copyFrom(D *pData, unsigned int nPitch)
+            {
+                NPP_ASSERT((ImagePacked<D, N, npp::ImageAllocator<D, N> >::width() * sizeof(npp::Pixel<D, N>) <= nPitch));
+                npp::ImageAllocator<D, N>::HostToDeviceCopy2D(ImagePacked<D, N, npp::ImageAllocator<D, N> >::data(),
+                                                              ImagePacked<D, N, npp::ImageAllocator<D, N> >::pitch(),
+                                                              pData,
+                                                              nPitch,
+                                                              ImagePacked<D, N, npp::ImageAllocator<D, N> >::width(),
+                                                              ImagePacked<D, N, npp::ImageAllocator<D, N> >::height());
+            }
+    };
+
+    typedef ImageNPP<Npp8u,  1>   ImageNPP_8u_C1;
+    typedef ImageNPP<Npp8u,  2>   ImageNPP_8u_C2;
+    typedef ImageNPP<Npp8u,  3>   ImageNPP_8u_C3;
+    typedef ImageNPP<Npp8u,  4>   ImageNPP_8u_C4;
+
+    typedef ImageNPP<Npp16u, 1>  ImageNPP_16u_C1;
+    typedef ImageNPP<Npp16u, 2>  ImageNPP_16u_C2;
+    typedef ImageNPP<Npp16u, 3>  ImageNPP_16u_C3;
+    typedef ImageNPP<Npp16u, 4>  ImageNPP_16u_C4;
+
+    typedef ImageNPP<Npp16s, 1>  ImageNPP_16s_C1;
+    typedef ImageNPP<Npp16s, 3>  ImageNPP_16s_C3;
+    typedef ImageNPP<Npp16s, 4>  ImageNPP_16s_C4;
+
+    typedef ImageNPP<Npp32s, 1>  ImageNPP_32s_C1;
+    typedef ImageNPP<Npp32s, 3>  ImageNPP_32s_C3;
+    typedef ImageNPP<Npp32s, 4>  ImageNPP_32s_C4;
+
+    typedef ImageNPP<Npp32f, 1>  ImageNPP_32f_C1;
+    typedef ImageNPP<Npp32f, 2>  ImageNPP_32f_C2;
+    typedef ImageNPP<Npp32f, 3>  ImageNPP_32f_C3;
+    typedef ImageNPP<Npp32f, 4>  ImageNPP_32f_C4;
+
+    typedef ImageNPP<Npp64f, 1>  ImageNPP_64f_C1;
+    typedef ImageNPP<Npp64f, 2>  ImageNPP_64f_C2;
+    typedef ImageNPP<Npp64f, 3>  ImageNPP_64f_C3;
+    typedef ImageNPP<Npp64f, 4>  ImageNPP_64f_C4;
+
+} // npp namespace
+
+#endif // NV_UTIL_NPP_IMAGES_NPP_H

Common/UtilNPP/Pixel.h

@@ -0,0 +1,126 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef NV_UTIL_PIXEL_H
+#define NV_UTIL_PIXEL_H
+
+#include "Exceptions.h"
+
+namespace npp
+{
+    template <typename D, size_t N>
+    struct Pixel
+    { };
+
+    template <typename D>
+    struct Pixel<D, 1>
+    {
+        D x;
+
+        const D &
+        operator[](size_t iChannel)
+        const
+        {
+            NPP_ASSERT(iChannel < 1);
+            return (&x)[iChannel];
+        }
+
+        D &
+        operator[](size_t iChannel)
+        {
+            NPP_ASSERT(iChannel < 1);
+            return (&x)[iChannel];
+        }
+    };
+
+    template <typename D>
+    struct Pixel<D, 2>
+    {
+        D x,y;
+
+        const D &
+        operator[](size_t iChannel)
+        const
+        {
+            NPP_ASSERT(iChannel < 2);
+            return (&x)[iChannel];
+        }
+
+        D &
+        operator[](size_t iChannel)
+        {
+            NPP_ASSERT(iChannel < 2);
+            return (&x)[iChannel];
+        }
+    };
+
+    template <typename D>
+    struct Pixel<D, 3>
+    {
+        D x,y,z;
+
+        const D &
+        operator[](size_t iChannel)
+        const
+        {
+            NPP_ASSERT(iChannel < 3);
+            return (&x)[iChannel];
+        }
+
+        D &
+        operator[](size_t iChannel)
+        {
+            NPP_ASSERT(iChannel < 3);
+            return (&x)[iChannel];
+        }
+    };
+
+    template <typename D>
+    struct Pixel<D, 4>
+    {
+        D x, y, z, w;
+
+        const D &
+        operator[](size_t iChannel)
+        const
+        {
+            NPP_ASSERT(iChannel < 4);
+            return (&x)[iChannel];
+        }
+
+        D &
+        operator[](size_t iChannel)
+        {
+            NPP_ASSERT(iChannel < 4);
+            return (&x)[iChannel];
+        }
+    };
+
+} // npp namespace
+
+#endif // NV_UTIL_PIXEL_H

Common/UtilNPP/Signal.h

@@ -0,0 +1,168 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef NV_UTIL_NPP_SIGNAL_H
+#define NV_UTIL_NPP_SIGNAL_H
+
+#include <cstring>
+
+namespace npp
+{
+    class Signal
+    {
+        public:
+            Signal() : nSize_(0)
+            { };
+
+            explicit
+            Signal(size_t nSize) : nSize_(nSize)
+            { };
+
+            Signal(const Signal &rSignal) : nSize_(rSignal.nSize_)
+            { };
+
+            virtual
+            ~Signal()
+            { }
+
+            Signal &
+            operator= (const Signal &rSignal)
+            {
+                nSize_ = rSignal.nSize_;
+                return *this;
+            }
+
+            size_t
+            size()
+            const
+            {
+                return nSize_;
+            }
+
+            void
+            swap(Signal &rSignal)
+            {
+                size_t nTemp = nSize_;
+                nSize_ = rSignal.nSize_;
+                rSignal.nSize_ = nTemp;
+            }
+
+
+        private:
+            size_t nSize_;
+    };
+
+    template<typename D, class A>
+    class SignalTemplate: public Signal
+    {
+        public:
+            typedef D tData;
+
+            SignalTemplate(): aValues_(0)
+            {
+                ;
+            }
+
+            SignalTemplate(size_t nSize): Signal(nSize)
+                , aValues_(0)
+            {
+                aValues_ = A::Malloc1D(size());
+            }
+
+            SignalTemplate(const SignalTemplate<D, A> &rSignal): Signal(rSignal)
+                , aValues_(0)
+            {
+                aValues_ = A::Malloc1D(size());
+                A::Copy1D(aValues_, rSignal.values(), size());
+            }
+
+            virtual
+            ~SignalTemplate()
+            {
+                A::Free1D(aValues_);
+            }
+
+            SignalTemplate &
+            operator= (const SignalTemplate<D, A> &rSignal)
+            {
+                // in case of self-assignment
+                if (&rSignal == this)
+                {
+                    return *this;
+                }
+
+                A::Free1D(aValues_);
+                this->aPixels_ = 0;
+
+                // assign parent class's data fields (width, height)
+                Signal::operator =(rSignal);
+
+                aValues_ = A::Malloc1D(size());
+                A::Copy1D(aValues_, rSignal.value(), size());
+
+                return *this;
+            }
+
+            /// Get a pointer to the pixel array.
+            ///     The result pointer can be offset to pixel at position (x, y) and
+            /// even negative offsets are allowed.
+            /// \param nX Horizontal pointer/array offset.
+            /// \param nY Vertical pointer/array offset.
+            /// \return Pointer to the pixel array (or first pixel in array with coordinates (nX, nY).
+            tData *
+            values(int i = 0)
+            {
+                return aValues_ + i;
+            }
+
+            const
+            tData *
+            values(int i = 0)
+            const
+            {
+                return aValues_ + i;
+            }
+
+            void
+            swap(SignalTemplate<D, A> &rSignal)
+            {
+                Signal::swap(rSignal);
+
+                tData *aTemp       = this->aValues_;
+                this->aValues_      = rSignal.aValues_;
+                rSignal.aValues_    = aTemp;
+            }
+
+        private:
+            D *aValues_;
+    };
+
+} // npp namespace
+
+
+#endif // NV_UTIL_NPP_SIGNAL_H

Common/UtilNPP/SignalAllocatorsCPU.h

@@ -0,0 +1,66 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef NV_UTIL_NPP_SIGNAL_ALLOCATORS_CPU_H
+#define NV_UTIL_NPP_SIGNAL_ALLOCATORS_CPU_H
+
+#include "Exceptions.h"
+
+namespace npp
+{
+
+    template <typename D>
+    class SignalAllocatorCPU
+    {
+        public:
+            static
+            D *
+            Malloc1D(unsigned int nSize)
+            {
+                return new D[nSize];;
+            };
+
+            static
+            void
+            Free1D(D *pPixels)
+            {
+                delete[] pPixels;
+            };
+
+            static
+            void
+            Copy1D(D *pDst, const D *pSrc, size_t nSize)
+            {
+                memcpy(pDst, pSrc, nSize * sizeof(D));
+            };
+
+    };
+
+} // npp namespace
+
+#endif // NV_UTIL_NPP_SIGNAL_ALLOCATORS_CPU_H

Common/UtilNPP/SignalAllocatorsNPP.h

@@ -0,0 +1,684 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef NV_UTIL_NPP_SIGNAL_ALLOCATORS_NPP_H
+#define NV_UTIL_NPP_SIGNAL_ALLOCATORS_NPP_H
+
+
+#include "Exceptions.h"
+
+#include <npps.h>
+#include <cuda_runtime.h>
+
+namespace npp
+{
+
+    template <typename D>
+    class SignalAllocator
+    {
+    };
+
+    template<>
+    class SignalAllocator<Npp8u>
+    {
+        public:
+            static
+            Npp8u *
+            Malloc1D(size_t nSize)
+            {
+                Npp8u *pResult = nppsMalloc_8u(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp8u *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp8u *pDst, const Npp8u *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp8u),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp8u *pDst, const Npp8u *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp8u), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp8u *pDst, const Npp8u *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp8u), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp16s>
+    {
+        public:
+            static
+            Npp16s *
+            Malloc1D(size_t nSize)
+            {
+                Npp16s *pResult = nppsMalloc_16s(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp16s *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp16s *pDst, const Npp16s *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp16s),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp16s *pDst, const Npp16s *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp16s), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp16s *pDst, const Npp16s *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp16s), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp16u>
+    {
+        public:
+            static
+            Npp16u *
+            Malloc1D(size_t nSize)
+            {
+                Npp16u *pResult = nppsMalloc_16u(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp16u *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp16u *pDst, const Npp16u *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp16u),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp16u *pDst, const Npp16u *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp16u), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp16u *pDst, const Npp16u *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp16u), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp16sc>
+    {
+        public:
+            static
+            Npp16sc *
+            Malloc1D(size_t nSize)
+            {
+                Npp16sc *pResult = nppsMalloc_16sc(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp16sc *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp16sc *pDst, const Npp16sc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp16sc),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp16sc *pDst, const Npp16sc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp16sc), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp16sc *pDst, const Npp16sc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp16sc), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp32u>
+    {
+        public:
+            static
+            Npp32u *
+            Malloc1D(size_t nSize)
+            {
+                Npp32u *pResult = nppsMalloc_32u(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp32u *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp32u *pDst, const Npp32u *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32u),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp32u *pDst, const Npp32u *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32u), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp32u *pDst, const Npp32u *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32u), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp32s>
+    {
+        public:
+            static
+            Npp32s *
+            Malloc1D(size_t nSize)
+            {
+                Npp32s *pResult = nppsMalloc_32s(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp32s *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp32s *pDst, const Npp32s *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32s),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp32s *pDst, const Npp32s *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32s), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp32s *pDst, const Npp32s *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32s), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp32sc>
+    {
+        public:
+            static
+            Npp32sc *
+            Malloc1D(size_t nSize)
+            {
+                Npp32sc *pResult = nppsMalloc_32sc(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp32sc *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp32sc *pDst, const Npp32sc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32sc),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp32sc *pDst, const Npp32sc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32sc), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp32sc *pDst, const Npp32sc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32sc), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp32f>
+    {
+        public:
+            static
+            Npp32f *
+            Malloc1D(size_t nSize)
+            {
+                Npp32f *pResult = nppsMalloc_32f(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp32f *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp32f *pDst, const Npp32f *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32f),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp32f *pDst, const Npp32f *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32f), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp32f *pDst, const Npp32f *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32f), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp32fc>
+    {
+        public:
+            static
+            Npp32fc *
+            Malloc1D(size_t nSize)
+            {
+                Npp32fc *pResult = nppsMalloc_32fc(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp32fc *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp32fc *pDst, const Npp32fc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32fc),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp32fc *pDst, const Npp32fc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32fc), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp32fc *pDst, const Npp32fc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp32fc), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp64s>
+    {
+        public:
+            static
+            Npp64s *
+            Malloc1D(size_t nSize)
+            {
+                Npp64s *pResult = nppsMalloc_64s(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp64s *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp64s *pDst, const Npp64s *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64s),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp64s *pDst, const Npp64s *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64s), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp64s *pDst, const Npp64s *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64s), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp64sc>
+    {
+        public:
+            static
+            Npp64sc *
+            Malloc1D(size_t nSize)
+            {
+                Npp64sc *pResult = nppsMalloc_64sc(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp64sc *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp64sc *pDst, const Npp64sc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64sc),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp64sc *pDst, const Npp64sc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64sc), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp64sc *pDst, const Npp64sc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64sc), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp64f>
+    {
+        public:
+            static
+            Npp64f *
+            Malloc1D(size_t nSize)
+            {
+                Npp64f *pResult = nppsMalloc_64f(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp64f *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp64f *pDst, const Npp64f *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64f),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp64f *pDst, const Npp64f *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64f), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp64f *pDst, const Npp64f *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64f), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+
+    template<>
+    class SignalAllocator<Npp64fc>
+    {
+        public:
+            static
+            Npp64fc *
+            Malloc1D(size_t nSize)
+            {
+                Npp64fc *pResult = nppsMalloc_64fc(static_cast<int>(nSize));
+                NPP_ASSERT(pResult != 0);
+
+                return pResult;
+            };
+
+            static
+            void
+            Free1D(Npp64fc *pValues)
+            {
+                nppsFree(pValues);
+            };
+
+            static
+            void
+            Copy1D(Npp64fc *pDst, const Npp64fc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64fc),cudaMemcpyDeviceToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            HostToDeviceCopy1D(Npp64fc *pDst, const Npp64fc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64fc), cudaMemcpyHostToDevice);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+
+            static
+            void
+            DeviceToHostCopy1D(Npp64fc *pDst, const Npp64fc *pSrc, size_t nSize)
+            {
+                cudaError_t eResult;
+                eResult = cudaMemcpy(pDst, pSrc, nSize * sizeof(Npp64fc), cudaMemcpyDeviceToHost);
+                NPP_ASSERT(cudaSuccess == eResult);
+            };
+    };
+} // npp namespace
+
+#endif // NV_UTIL_NPP_SIGNAL_ALLOCATORS_NPP_H

Common/UtilNPP/SignalsCPU.h

@@ -0,0 +1,107 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef NV_UTIL_NPP_SIGNALS_CPU_H
+#define NV_UTIL_NPP_SIGNALS_CPU_H
+
+#include "Signal.h"
+
+#include "SignalAllocatorsCPU.h"
+#include "Exceptions.h"
+
+#include <npp.h>
+
+
+namespace npp
+{
+
+    template<typename D, class A>
+    class SignalCPU: public npp::SignalTemplate<D, A>
+    {
+        public:
+            typedef typename npp::SignalTemplate<D, A>::tData tData;
+
+            SignalCPU()
+            {
+                ;
+            }
+
+            SignalCPU(size_t nSize): SignalTemplate<D, A>(nSize)
+            {
+                ;
+            }
+
+            SignalCPU(const SignalCPU<D, A> &rSignal): SignalTemplate<D, A>(rSignal)
+            {
+                ;
+            }
+
+            virtual
+            ~SignalCPU()
+            {
+                ;
+            }
+
+            SignalCPU &
+            operator= (const SignalCPU<D,A> &rSignal)
+            {
+                SignalTemplate<D, A>::operator= (rSignal);
+
+                return *this;
+            }
+
+            tData &
+            operator [](unsigned int i)
+            {
+                return *SignalTemplate<D, A>::values(i);
+            }
+
+            tData
+            operator [](unsigned int i)
+            const
+            {
+                return *SignalTemplate<D, A>::values(i);
+            }
+
+    };
+
+    typedef SignalCPU<Npp8u,   npp::SignalAllocatorCPU<Npp8u>   >   SignalCPU_8u;
+    typedef SignalCPU<Npp32s,  npp::SignalAllocatorCPU<Npp32s>  >   SignalCPU_32s;
+    typedef SignalCPU<Npp16s,  npp::SignalAllocatorCPU<Npp16s>  >   SignalCPU_16s;
+    typedef SignalCPU<Npp16sc, npp::SignalAllocatorCPU<Npp16sc> >   SignalCPU_16sc;
+    typedef SignalCPU<Npp32sc, npp::SignalAllocatorCPU<Npp32sc> >   SignalCPU_32sc;
+    typedef SignalCPU<Npp32f,  npp::SignalAllocatorCPU<Npp32f>  >   SignalCPU_32f;
+    typedef SignalCPU<Npp32fc, npp::SignalAllocatorCPU<Npp32fc> >   SignalCPU_32fc;
+    typedef SignalCPU<Npp64s,  npp::SignalAllocatorCPU<Npp64s>  >   SignalCPU_64s;
+    typedef SignalCPU<Npp64sc, npp::SignalAllocatorCPU<Npp64sc> >   SignalCPU_64sc;
+    typedef SignalCPU<Npp64f,  npp::SignalAllocatorCPU<Npp64f>  >   SignalCPU_64f;
+    typedef SignalCPU<Npp64fc, npp::SignalAllocatorCPU<Npp64fc> >   SignalCPU_64fc;
+
+} // npp namespace
+
+#endif // NV_UTIL_NPP_SIGNALS_CPU_H

Common/UtilNPP/SignalsNPP.h

@@ -0,0 +1,113 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef NV_UTIL_NPP_SIGNALS_NPP_H
+#define NV_UTIL_NPP_SIGNALS_NPP_H
+
+#include "Exceptions.h"
+#include "Signal.h"
+
+#include "SignalAllocatorsNPP.h"
+#include <cuda_runtime.h>
+
+namespace npp
+{
+    // forward declaration
+    template<typename D, class A> class SignalCPU;
+
+    template<typename D>
+    class SignalNPP: public npp::SignalTemplate<D, npp::SignalAllocator<D> >
+    {
+        public:
+            SignalNPP()
+            {
+                ;
+            }
+
+            explicit
+            SignalNPP(size_t nSize): SignalTemplate<D, npp::SignalAllocator<D> >(nSize)
+            {
+                ;
+            }
+
+            SignalNPP(const SignalNPP<D> &rSignal): SignalTemplate<D, npp::SignalAllocator<D> >(rSignal)
+            {
+                ;
+            }
+
+            template<class X>
+            explicit
+            SignalNPP(const SignalCPU<D, X> &rSignal): SignalTemplate<D, npp::SignalAllocator<D> >(rSignal.size())
+            {
+                npp::SignalAllocator<D>::HostToDeviceCopy1D(SignalTemplate<D, npp::SignalAllocator<D> >::values(),
+                                                            rSignal.values(), SignalTemplate<D, npp::SignalAllocator<D> >::size());
+            }
+
+            virtual
+            ~SignalNPP()
+            {
+                ;
+            }
+
+            SignalNPP &
+            operator= (const SignalNPP<D> &rSignal)
+            {
+                SignalTemplate<D, npp::SignalAllocator<D> >::operator= (rSignal);
+
+                return *this;
+            }
+
+            void
+            copyTo(D *pValues)
+            const
+            {
+                npp::SignalAllocator<D>::DeviceToHostCopy1D(pValues, SignalTemplate<D, npp::SignalAllocator<D> >::values(), SignalTemplate<D, npp::SignalAllocator<D> >::size());
+            }
+
+            void
+            copyFrom(D *pValues)
+            {
+                npp::SignalAllocator<D>::HostToDeviceCopy1D(SignalTemplate<D, npp::SignalAllocator<D> >::values(), pValues, SignalTemplate<D, npp::SignalAllocator<D> >::size());
+            }
+    };
+
+    typedef SignalNPP<Npp8u>    SignalNPP_8u;
+    typedef SignalNPP<Npp16s>   SignalNPP_16s;
+    typedef SignalNPP<Npp16sc>  SignalNPP_16sc;
+    typedef SignalNPP<Npp32s>   SignalNPP_32s;
+    typedef SignalNPP<Npp32sc>  SignalNPP_32sc;
+    typedef SignalNPP<Npp32f>   SignalNPP_32f;
+    typedef SignalNPP<Npp32fc>  SignalNPP_32fc;
+    typedef SignalNPP<Npp64s>   SignalNPP_64s;
+    typedef SignalNPP<Npp64sc>  SignalNPP_64sc;
+    typedef SignalNPP<Npp64f>   SignalNPP_64f;
+    typedef SignalNPP<Npp64fc>  SignalNPP_64fc;
+
+} // npp namespace
+
+#endif // NV_UTIL_NPP_SIGNALS_NPP_H

Common/drvapi_error_string.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions

Common/dynlink_d3d10.h

@@ -0,0 +1,294 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+//--------------------------------------------------------------------------------------
+// File: dynlink_d3d10.h
+//
+// Shortcut macros and functions for using DX objects
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+//--------------------------------------------------------------------------------------
+
+#ifndef _DYNLINK_D3D10_H_
+#define _DYNLINK_D3D10_H_
+
+// Standard Windows includes
+#include <windows.h>
+#include <initguid.h>
+#include <assert.h>
+#include <wchar.h>
+#include <mmsystem.h>
+#include <commctrl.h> // for InitCommonControls() 
+#include <shellapi.h> // for ExtractIcon()
+#include <new.h>      // for placement new
+#include <shlobj.h>
+#include <math.h>
+#include <limits.h>
+#include <stdio.h>
+
+// CRT's memory leak detection
+#if defined(DEBUG) || defined(_DEBUG)
+#include <crtdbg.h>
+#endif
+
+// Direct3D9 includes
+#include <d3d9.h>
+
+// Direct3D10 includes
+#include <dxgi.h>
+#include <d3d10_1.h>
+#include <d3d10.h>
+
+// XInput includes
+#include <xinput.h>
+
+// strsafe.h deprecates old unsecure string functions.  If you
+// really do not want to it to (not recommended), then uncomment the next line
+//#define STRSAFE_NO_DEPRECATE
+
+#ifndef STRSAFE_NO_DEPRECATE
+#pragma deprecated("strncpy")
+#pragma deprecated("wcsncpy")
+#pragma deprecated("_tcsncpy")
+#pragma deprecated("wcsncat")
+#pragma deprecated("strncat")
+#pragma deprecated("_tcsncat")
+#endif
+
+#pragma warning( disable : 4996 ) // disable deprecated warning 
+#include <strsafe.h>
+#pragma warning( default : 4996 )
+
+#include <DirectXMath.h>
+
+using namespace DirectX;
+//--------------------------------------------------------------------------------------
+// Structs
+//--------------------------------------------------------------------------------------
+struct DXUTD3D9DeviceSettings
+{
+    UINT AdapterOrdinal;
+    D3DDEVTYPE DeviceType;
+    D3DFORMAT AdapterFormat;
+    DWORD BehaviorFlags;
+    D3DPRESENT_PARAMETERS pp;
+};
+
+struct DXUTD3D10DeviceSettings
+{
+    UINT AdapterOrdinal;
+    D3D10_DRIVER_TYPE DriverType;
+    UINT Output;
+    DXGI_SWAP_CHAIN_DESC sd;
+    UINT32 CreateFlags;
+    UINT32 SyncInterval;
+    DWORD PresentFlags;
+    bool AutoCreateDepthStencil; // DXUT will create the a depth stencil resource and view if true
+    DXGI_FORMAT AutoDepthStencilFormat;
+};
+
+enum DXUTDeviceVersion { DXUT_D3D9_DEVICE, DXUT_D3D10_DEVICE };
+struct DXUTDeviceSettings
+{
+    DXUTDeviceVersion ver;
+    union
+    {
+        DXUTD3D9DeviceSettings d3d9; // only valid if ver == DXUT_D3D9_DEVICE
+        DXUTD3D10DeviceSettings d3d10; // only valid if ver == DXUT_D3D10_DEVICE
+    };
+};
+
+
+//--------------------------------------------------------------------------------------
+// Error codes
+//--------------------------------------------------------------------------------------
+#define DXUTERR_NODIRECT3D              MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0901)
+#define DXUTERR_NOCOMPATIBLEDEVICES     MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0902)
+#define DXUTERR_MEDIANOTFOUND           MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0903)
+#define DXUTERR_NONZEROREFCOUNT         MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0904)
+#define DXUTERR_CREATINGDEVICE          MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0905)
+#define DXUTERR_RESETTINGDEVICE         MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0906)
+#define DXUTERR_CREATINGDEVICEOBJECTS   MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0907)
+#define DXUTERR_RESETTINGDEVICEOBJECTS  MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x0908)
+#define DXUTERR_DEVICEREMOVED           MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x090A)
+
+
+typedef HRESULT(WINAPI *LPCREATEDXGIFACTORY)(REFIID, void **);
+typedef HRESULT(WINAPI *LPD3D10CREATEDEVICE)(IDXGIAdapter *, D3D10_DRIVER_TYPE, HMODULE, UINT, UINT32,
+                                             ID3D10Device **);
+typedef HRESULT(WINAPI *LPD3D10CREATEDEVICE1)(IDXGIAdapter *, D3D10_DRIVER_TYPE, HMODULE, UINT,
+                                              D3D10_FEATURE_LEVEL1, UINT, ID3D10Device1 **);
+typedef HRESULT(WINAPI *LPD3D10CREATESTATEBLOCK)(ID3D10Device *pDevice, D3D10_STATE_BLOCK_MASK *pStateBlockMask,
+                                                 ID3D10StateBlock **ppStateBlock);
+typedef HRESULT(WINAPI *LPD3D10STATEBLOCKMASKUNION)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB,
+                                                    D3D10_STATE_BLOCK_MASK *pResult);
+typedef HRESULT(WINAPI *LPD3D10STATEBLOCKMASKINTERSECT)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB,
+                                                        D3D10_STATE_BLOCK_MASK *pResult);
+typedef HRESULT(WINAPI *LPD3D10STATEBLOCKMASKDIFFERENCE)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB,
+                                                         D3D10_STATE_BLOCK_MASK *pResult);
+typedef HRESULT(WINAPI *LPD3D10STATEBLOCKMASKENABLECAPTURE)(D3D10_STATE_BLOCK_MASK *pMask,
+                                                            D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart,
+                                                            UINT RangeLength);
+typedef HRESULT(WINAPI *LPD3D10STATEBLOCKMASKDISABLECAPTURE)(D3D10_STATE_BLOCK_MASK *pMask,
+        D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart,
+        UINT RangeLength);
+typedef HRESULT(WINAPI *LPD3D10STATEBLOCKMASKENABLEALL)(D3D10_STATE_BLOCK_MASK *pMask);
+typedef HRESULT(WINAPI *LPD3D10STATEBLOCKMASKDISABLEALL)(D3D10_STATE_BLOCK_MASK *pMask);
+typedef BOOL (WINAPI *LPD3D10STATEBLOCKMASKGETSETTING)(D3D10_STATE_BLOCK_MASK *pMask,
+                                                       D3D10_DEVICE_STATE_TYPES StateType, UINT Entry);
+
+typedef HRESULT(WINAPI *LPD3D10COMPILEEFFECTFROMMEMORY)(void *pData, SIZE_T DataLength, LPCSTR pSrcFileName,
+                                                        CONST D3D10_SHADER_MACRO *pDefines,
+                                                        ID3D10Include *pInclude, UINT HLSLFlags, UINT FXFlags,
+                                                        ID3D10Blob **ppCompiledEffect, ID3D10Blob **ppErrors);
+typedef HRESULT(WINAPI *LPD3D10CREATEEFFECTFROMMEMORY)(void *pData, SIZE_T DataLength, UINT FXFlags,
+                                                       ID3D10Device *pDevice,
+                                                       ID3D10EffectPool *pEffectPool,
+                                                       ID3D10Effect **ppEffect);
+typedef HRESULT(WINAPI *LPD3D10CREATEEFFECTPOOLFROMMEMORY)(void *pData, SIZE_T DataLength, UINT FXFlags,
+                                                           ID3D10Device *pDevice, ID3D10EffectPool **ppEffectPool);
+
+typedef HRESULT(WINAPI *LPD3D10CREATEDEVICEANDSWAPCHAIN)(IDXGIAdapter *pAdapter,
+                                                         D3D10_DRIVER_TYPE DriverType,
+                                                         HMODULE Software,
+                                                         UINT Flags,
+                                                         UINT SDKVersion,
+                                                         DXGI_SWAP_CHAIN_DESC *pSwapChainDesc,
+                                                         IDXGISwapChain **ppSwapChain,
+                                                         ID3D10Device **ppDevice);
+
+typedef HRESULT(WINAPI *LPD3D10CREATEDEVICEANDSWAPCHAIN1)(IDXGIAdapter *pAdapter,
+                                                          D3D10_DRIVER_TYPE DriverType,
+                                                          HMODULE Software,
+                                                          UINT Flags,
+                                                          D3D10_FEATURE_LEVEL1 HardwareLevel,
+                                                          UINT SDKVersion,
+                                                          DXGI_SWAP_CHAIN_DESC *pSwapChainDesc,
+                                                          IDXGISwapChain **ppSwapChain,
+                                                          ID3D10Device1 **ppDevice);
+
+// Module and function pointers
+static HMODULE                              g_hModDXGI = NULL;
+static HMODULE                              g_hModD3D10 = NULL;
+static HMODULE                              g_hModD3D101 = NULL;
+static LPCREATEDXGIFACTORY                  sFnPtr_CreateDXGIFactory = NULL;
+static LPD3D10CREATESTATEBLOCK              sFnPtr_D3D10CreateStateBlock = NULL;
+static LPD3D10CREATEDEVICE                  sFnPtr_D3D10CreateDevice = NULL;
+static LPD3D10CREATEDEVICE1                 sFnPtr_D3D10CreateDevice1 = NULL;
+static LPD3D10STATEBLOCKMASKUNION           sFnPtr_D3D10StateBlockMaskUnion = NULL;
+static LPD3D10STATEBLOCKMASKINTERSECT       sFnPtr_D3D10StateBlockMaskIntersect = NULL;
+static LPD3D10STATEBLOCKMASKDIFFERENCE      sFnPtr_D3D10StateBlockMaskDifference = NULL;
+static LPD3D10STATEBLOCKMASKENABLECAPTURE   sFnPtr_D3D10StateBlockMaskEnableCapture = NULL;
+static LPD3D10STATEBLOCKMASKDISABLECAPTURE  sFnPtr_D3D10StateBlockMaskDisableCapture = NULL;
+static LPD3D10STATEBLOCKMASKENABLEALL       sFnPtr_D3D10StateBlockMaskEnableAll = NULL;
+static LPD3D10STATEBLOCKMASKDISABLEALL      sFnPtr_D3D10StateBlockMaskDisableAll = NULL;
+static LPD3D10STATEBLOCKMASKGETSETTING      sFnPtr_D3D10StateBlockMaskGetSetting = NULL;
+static LPD3D10COMPILEEFFECTFROMMEMORY       sFnPtr_D3D10CompileEffectFromMemory = NULL;
+static LPD3D10CREATEEFFECTFROMMEMORY        sFnPtr_D3D10CreateEffectFromMemory = NULL;
+static LPD3D10CREATEEFFECTPOOLFROMMEMORY    sFnPtr_D3D10CreateEffectPoolFromMemory = NULL;
+static LPD3D10CREATEDEVICEANDSWAPCHAIN      sFnPtr_D3D10CreateDeviceAndSwapChain  = NULL;
+static LPD3D10CREATEDEVICEANDSWAPCHAIN1     sFnPtr_D3D10CreateDeviceAndSwapChain1 = NULL;
+
+// unload the D3D10 DLLs
+static bool dynlinkUnloadD3D10API(void)
+{
+    if (g_hModD3D10)
+    {
+        FreeLibrary(g_hModD3D10);
+        g_hModD3D10 = NULL;
+    }
+
+    if (g_hModDXGI)
+    {
+        FreeLibrary(g_hModDXGI);
+        g_hModDXGI = NULL;
+    }
+
+    if (g_hModD3D101)
+    {
+        FreeLibrary(g_hModD3D101);
+        g_hModD3D101 = NULL;
+    }
+
+    return true;
+}
+
+// Dynamically load the D3D10 DLLs loaded and map the function pointers
+static bool dynlinkLoadD3D10API(void)
+{
+    // First check to see if the D3D10 Library is present.
+    // if it succeeds, then we can call GetProcAddress to grab all of the DX10 functions
+    g_hModD3D10 = LoadLibrary("d3d10.dll");
+
+    if (g_hModD3D10 != NULL)
+    {
+        sFnPtr_D3D10CreateStateBlock             = (LPD3D10CREATESTATEBLOCK)           GetProcAddress(g_hModD3D10, "D3D10CreateStateBlock");
+        sFnPtr_D3D10CreateDevice                 = (LPD3D10CREATEDEVICE)           GetProcAddress(g_hModD3D10, "D3D10CreateDevice");
+
+        sFnPtr_D3D10StateBlockMaskUnion          = (LPD3D10STATEBLOCKMASKUNION)        GetProcAddress(g_hModD3D10, "D3D10StateBlockMaskUnion");
+        sFnPtr_D3D10StateBlockMaskIntersect      = (LPD3D10STATEBLOCKMASKINTERSECT)    GetProcAddress(g_hModD3D10, "D3D10StateBlockMaskIntersect");
+        sFnPtr_D3D10StateBlockMaskDifference     = (LPD3D10STATEBLOCKMASKDIFFERENCE)   GetProcAddress(g_hModD3D10, "D3D10StateBlockMaskDifference");
+        sFnPtr_D3D10StateBlockMaskEnableCapture  = (LPD3D10STATEBLOCKMASKENABLECAPTURE) GetProcAddress(g_hModD3D10, "D3D10StateBlockMaskEnableCapture");
+        sFnPtr_D3D10StateBlockMaskDisableCapture = (LPD3D10STATEBLOCKMASKDISABLECAPTURE)GetProcAddress(g_hModD3D10, "D3D10StateBlockMaskDisableCapture");
+
+        sFnPtr_D3D10StateBlockMaskEnableAll      = (LPD3D10STATEBLOCKMASKENABLEALL)    GetProcAddress(g_hModD3D10, "D3D10StateBlockMaskEnableAll");
+        sFnPtr_D3D10StateBlockMaskDisableAll     = (LPD3D10STATEBLOCKMASKDISABLEALL)   GetProcAddress(g_hModD3D10, "D3D10StateBlockMaskDisableAll");
+        sFnPtr_D3D10StateBlockMaskGetSetting     = (LPD3D10STATEBLOCKMASKGETSETTING)   GetProcAddress(g_hModD3D10, "D3D10StateBlockMaskGetSetting");
+
+        sFnPtr_D3D10CompileEffectFromMemory      = (LPD3D10COMPILEEFFECTFROMMEMORY)    GetProcAddress(g_hModD3D10, "D3D10CompileEffectFromMemory");
+        sFnPtr_D3D10CreateEffectFromMemory       = (LPD3D10CREATEEFFECTFROMMEMORY)     GetProcAddress(g_hModD3D10, "D3D10CreateEffectFromMemory");
+        sFnPtr_D3D10CreateEffectPoolFromMemory   = (LPD3D10CREATEEFFECTPOOLFROMMEMORY) GetProcAddress(g_hModD3D10, "D3D10CreateEffectPoolFromMemory");
+
+        sFnPtr_D3D10CreateDeviceAndSwapChain     = (LPD3D10CREATEDEVICEANDSWAPCHAIN)    GetProcAddress(g_hModD3D10, "D3D10CreateDeviceAndSwapChain");
+    }
+
+    g_hModDXGI = LoadLibrary("dxgi.dll");
+
+    if (g_hModDXGI)
+    {
+        sFnPtr_CreateDXGIFactory                 = (LPCREATEDXGIFACTORY)           GetProcAddress(g_hModDXGI , "CreateDXGIFactory");
+    }
+
+    // This may fail if this machine isn't Windows Vista SP1 or later
+    g_hModD3D101 = LoadLibrary("d3d10_1.dll");
+
+    if (g_hModD3D101 != NULL)
+    {
+        sFnPtr_D3D10CreateDevice1                = (LPD3D10CREATEDEVICE1)              GetProcAddress(g_hModD3D101, "D3D10CreateDevice1");
+        sFnPtr_D3D10CreateDeviceAndSwapChain1    = (LPD3D10CREATEDEVICEANDSWAPCHAIN1)   GetProcAddress(g_hModD3D101, "D3D10CreateDeviceAndSwapChain1");
+    }
+
+    if (g_hModD3D10 == NULL || g_hModDXGI == NULL || g_hModD3D101 == NULL)
+    {
+        dynlinkUnloadD3D10API();
+        return false;
+    }
+
+    return true;
+}
+
+#endif

Common/dynlink_d3d11.h

@@ -0,0 +1,160 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+//--------------------------------------------------------------------------------------
+// File: dynlink_d3d11.h
+//
+// Shortcut macros and functions for using DX objects
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+//--------------------------------------------------------------------------------------
+
+#ifndef _DYNLINK_D3D11_H_
+#define _DYNLINK_D3D11_H_
+
+// Standard Windows includes
+#include <windows.h>
+#include <initguid.h>
+#include <assert.h>
+#include <wchar.h>
+#include <mmsystem.h>
+#include <commctrl.h> // for InitCommonControls() 
+#include <shellapi.h> // for ExtractIcon()
+#include <new.h>      // for placement new
+#include <shlobj.h>
+#include <math.h>
+#include <limits.h>
+#include <stdio.h>
+
+// CRT's memory leak detection
+#if defined(DEBUG) || defined(_DEBUG)
+#include <crtdbg.h>
+#endif
+
+// Direct3D10 includes
+#include <dxgi.h>
+#include <d3d11.h>
+// #include <..\Samples\C++\Effects11\Inc\d3dx11effect.h>
+
+// XInput includes
+#include <xinput.h>
+
+// strsafe.h deprecates old unsecure string functions.  If you
+// really do not want to it to (not recommended), then uncomment the next line
+//#define STRSAFE_NO_DEPRECATE
+
+#ifndef STRSAFE_NO_DEPRECATE
+#pragma deprecated("strncpy")
+#pragma deprecated("wcsncpy")
+#pragma deprecated("_tcsncpy")
+#pragma deprecated("wcsncat")
+#pragma deprecated("strncat")
+#pragma deprecated("_tcsncat")
+#endif
+
+#pragma warning( disable : 4996 ) // disable deprecated warning 
+#include <strsafe.h>
+#pragma warning( default : 4996 )
+
+typedef HRESULT(WINAPI *LPCREATEDXGIFACTORY)(REFIID, void **);
+typedef HRESULT(WINAPI *LPD3D11CREATEDEVICEANDSWAPCHAIN)(__in_opt IDXGIAdapter *pAdapter, D3D_DRIVER_TYPE DriverType, HMODULE Software, UINT Flags, __in_ecount_opt(FeatureLevels) CONST D3D_FEATURE_LEVEL *pFeatureLevels, UINT FeatureLevels, UINT SDKVersion, __in_opt CONST DXGI_SWAP_CHAIN_DESC *pSwapChainDesc, __out_opt IDXGISwapChain **ppSwapChain, __out_opt ID3D11Device **ppDevice, __out_opt D3D_FEATURE_LEVEL *pFeatureLevel, __out_opt ID3D11DeviceContext **ppImmediateContext);
+typedef HRESULT(WINAPI *LPD3D11CREATEDEVICE)(IDXGIAdapter *, D3D_DRIVER_TYPE, HMODULE, UINT32, D3D_FEATURE_LEVEL *, UINT, UINT32, ID3D11Device **, D3D_FEATURE_LEVEL *, ID3D11DeviceContext **);
+
+static HMODULE                              s_hModDXGI = NULL;
+static LPCREATEDXGIFACTORY                  sFnPtr_CreateDXGIFactory = NULL;
+static HMODULE                              s_hModD3D11 = NULL;
+static LPD3D11CREATEDEVICE                  sFnPtr_D3D11CreateDevice = NULL;
+static LPD3D11CREATEDEVICEANDSWAPCHAIN      sFnPtr_D3D11CreateDeviceAndSwapChain = NULL;
+
+// unload the D3D10 DLLs
+static bool dynlinkUnloadD3D11API(void)
+{
+    if (s_hModDXGI)
+    {
+        FreeLibrary(s_hModDXGI);
+        s_hModDXGI = NULL;
+    }
+
+    if (s_hModD3D11)
+    {
+        FreeLibrary(s_hModD3D11);
+        s_hModD3D11 = NULL;
+    }
+
+    return true;
+}
+
+// Dynamically load the D3D11 DLLs loaded and map the function pointers
+static bool dynlinkLoadD3D11API(void)
+{
+    // If both modules are non-NULL, this function has already been called.  Note
+    // that this doesn't guarantee that all ProcAddresses were found.
+    if (s_hModD3D11 != NULL && s_hModDXGI != NULL)
+    {
+        return true;
+    }
+
+#if 1
+    // This may fail if Direct3D 11 isn't installed
+    s_hModD3D11 = LoadLibrary("d3d11.dll");
+
+    if (s_hModD3D11 != NULL)
+    {
+        sFnPtr_D3D11CreateDevice = (LPD3D11CREATEDEVICE)GetProcAddress(s_hModD3D11, "D3D11CreateDevice");
+        sFnPtr_D3D11CreateDeviceAndSwapChain = (LPD3D11CREATEDEVICEANDSWAPCHAIN)GetProcAddress(s_hModD3D11, "D3D11CreateDeviceAndSwapChain");
+    }
+    else
+    {
+        printf("\nLoad d3d11.dll failed\n");
+        fflush(0);
+    }
+
+    if (!sFnPtr_CreateDXGIFactory)
+    {
+        s_hModDXGI = LoadLibrary("dxgi.dll");
+
+        if (s_hModDXGI)
+        {
+            sFnPtr_CreateDXGIFactory = (LPCREATEDXGIFACTORY)GetProcAddress(s_hModDXGI, "CreateDXGIFactory1");
+        }
+
+        return (s_hModDXGI != NULL) && (s_hModD3D11 != NULL);
+    }
+
+    return (s_hModD3D11 != NULL);
+#else
+    sFnPtr_D3D11CreateDevice = (LPD3D11CREATEDEVICE)D3D11CreateDeviceAndSwapChain;
+    sFnPtr_D3D11CreateDeviceAndSwapChain = (LPD3D11CREATEDEVICEANDSWAPCHAIN)D3D11CreateDeviceAndSwapChain;
+    //sFnPtr_D3DX11CreateEffectFromMemory  = ( LPD3DX11CREATEEFFECTFROMMEMORY )D3DX11CreateEffectFromMemory;
+    sFnPtr_D3DX11CompileFromMemory = (LPD3DX11COMPILEFROMMEMORY)D3DX11CompileFromMemory;
+    sFnPtr_CreateDXGIFactory = (LPCREATEDXGIFACTORY)CreateDXGIFactory;
+    return true;
+#endif
+    return true;
+}
+
+#endif

Common/exception.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions

Common/helper_cuda.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -579,24 +579,12 @@ static const char *_cudaGetErrorEnum(NppStatus error) {
 }
 #endif
 
-#ifdef __DRIVER_TYPES_H__
-#ifndef DEVICE_RESET
-#define DEVICE_RESET cudaDeviceReset();
-#endif
-#else
-#ifndef DEVICE_RESET
-#define DEVICE_RESET
-#endif
-#endif
-
 template <typename T>
 void check(T result, char const *const func, const char *const file,
            int const line) {
   if (result) {
     fprintf(stderr, "CUDA error at %s:%d code=%d(%s) \"%s\" \n", file, line,
             static_cast<unsigned int>(result), _cudaGetErrorEnum(result), func);
-    DEVICE_RESET
-    // Make sure we call CUDA Device Reset before exiting
     exit(EXIT_FAILURE);
   }
 }
@@ -619,7 +607,6 @@ inline void __getLastCudaError(const char *errorMessage, const char *file,
             " %s : (%d) %s.\n",
             file, line, errorMessage, static_cast<int>(err),
             cudaGetErrorString(err));
-    DEVICE_RESET
     exit(EXIT_FAILURE);
   }
 }
@@ -676,6 +663,11 @@ inline int _ConvertSMVer2Cores(int major, int minor) {
       {0x70,  64},
       {0x72,  64},
       {0x75,  64},
+      {0x80,  64},
+      {0x86, 128},
+      {0x87, 128},
+      {0x89, 128},
+      {0x90, 128},
       {-1, -1}};
 
   int index = 0;
@@ -696,6 +688,55 @@ inline int _ConvertSMVer2Cores(int major, int minor) {
       major, minor, nGpuArchCoresPerSM[index - 1].Cores);
   return nGpuArchCoresPerSM[index - 1].Cores;
 }
+
+inline const char* _ConvertSMVer2ArchName(int major, int minor) {
+  // Defines for GPU Architecture types (using the SM version to determine
+  // the GPU Arch name)
+  typedef struct {
+    int SM;  // 0xMm (hexidecimal notation), M = SM Major version,
+    // and m = SM minor version
+    const char* name;
+  } sSMtoArchName;
+
+  sSMtoArchName nGpuArchNameSM[] = {
+      {0x30, "Kepler"},
+      {0x32, "Kepler"},
+      {0x35, "Kepler"},
+      {0x37, "Kepler"},
+      {0x50, "Maxwell"},
+      {0x52, "Maxwell"},
+      {0x53, "Maxwell"},
+      {0x60, "Pascal"},
+      {0x61, "Pascal"},
+      {0x62, "Pascal"},
+      {0x70, "Volta"},
+      {0x72, "Xavier"},
+      {0x75, "Turing"},
+      {0x80, "Ampere"},
+      {0x86, "Ampere"},
+      {0x87, "Ampere"},
+      {0x89, "Ada"},
+      {0x90, "Hopper"},
+      {-1, "Graphics Device"}};
+
+  int index = 0;
+
+  while (nGpuArchNameSM[index].SM != -1) {
+    if (nGpuArchNameSM[index].SM == ((major << 4) + minor)) {
+      return nGpuArchNameSM[index].name;
+    }
+
+    index++;
+  }
+
+  // If we don't find the values, we default use the previous one
+  // to run properly
+  printf(
+      "MapSMtoArchName for SM %d.%d is undefined."
+      "  Default to use %s\n",
+      major, minor, nGpuArchNameSM[index - 1].name);
+  return nGpuArchNameSM[index - 1].name;
+}
   // end of GPU Architecture definitions
 
 #ifdef __CUDA_RUNTIME_H__
@@ -727,23 +768,24 @@ inline int gpuDeviceInit(int devID) {
     return -devID;
   }
 
-  cudaDeviceProp deviceProp;
-  checkCudaErrors(cudaGetDeviceProperties(&deviceProp, devID));
-
-  if (deviceProp.computeMode == cudaComputeModeProhibited) {
+  int computeMode = -1, major = 0, minor = 0;
+  checkCudaErrors(cudaDeviceGetAttribute(&computeMode, cudaDevAttrComputeMode, devID));
+  checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, devID));
+  checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, devID));
+  if (computeMode == cudaComputeModeProhibited) {
     fprintf(stderr,
             "Error: device is running in <Compute Mode "
             "Prohibited>, no threads can use cudaSetDevice().\n");
     return -1;
   }
 
-  if (deviceProp.major < 1) {
+  if (major < 1) {
     fprintf(stderr, "gpuDeviceInit(): GPU device does not support CUDA.\n");
     exit(EXIT_FAILURE);
   }
 
   checkCudaErrors(cudaSetDevice(devID));
-  printf("gpuDeviceInit() CUDA Device [%d]: \"%s\n", devID, deviceProp.name);
+  printf("gpuDeviceInit() CUDA Device [%d]: \"%s\n", devID, _ConvertSMVer2ArchName(major, minor));
 
   return devID;
 }
@@ -756,7 +798,6 @@ inline int gpuGetMaxGflopsDeviceId() {
   int devices_prohibited = 0;
 
   uint64_t max_compute_perf = 0;
-  cudaDeviceProp deviceProp;
   checkCudaErrors(cudaGetDeviceCount(&device_count));
 
   if (device_count == 0) {
@@ -770,20 +811,36 @@ inline int gpuGetMaxGflopsDeviceId() {
   current_device = 0;
 
   while (current_device < device_count) {
-    cudaGetDeviceProperties(&deviceProp, current_device);
+    int computeMode = -1, major = 0, minor = 0;
+    checkCudaErrors(cudaDeviceGetAttribute(&computeMode, cudaDevAttrComputeMode, current_device));
+    checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, current_device));
+    checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, current_device));
 
     // If this GPU is not running on Compute Mode prohibited,
     // then we can add it to the list
-    if (deviceProp.computeMode != cudaComputeModeProhibited) {
-      if (deviceProp.major == 9999 && deviceProp.minor == 9999) {
+    if (computeMode != cudaComputeModeProhibited) {
+      if (major == 9999 && minor == 9999) {
         sm_per_multiproc = 1;
       } else {
         sm_per_multiproc =
-            _ConvertSMVer2Cores(deviceProp.major, deviceProp.minor);
+            _ConvertSMVer2Cores(major,  minor);
       }
-
-      uint64_t compute_perf = (uint64_t)deviceProp.multiProcessorCount *
-                              sm_per_multiproc * deviceProp.clockRate;
+      int multiProcessorCount = 0, clockRate = 0;
+      checkCudaErrors(cudaDeviceGetAttribute(&multiProcessorCount, cudaDevAttrMultiProcessorCount, current_device));
+      cudaError_t result = cudaDeviceGetAttribute(&clockRate, cudaDevAttrClockRate, current_device);
+      if (result != cudaSuccess) {
+        // If cudaDevAttrClockRate attribute is not supported we
+        // set clockRate as 1, to consider GPU with most SMs and CUDA Cores.
+        if(result == cudaErrorInvalidValue) {
+          clockRate = 1;
+        }
+        else {
+          fprintf(stderr, "CUDA error at %s:%d code=%d(%s) \n", __FILE__, __LINE__,
+            static_cast<unsigned int>(result), _cudaGetErrorEnum(result));
+          exit(EXIT_FAILURE);
+        }
+      }
+      uint64_t compute_perf = (uint64_t)multiProcessorCount * sm_per_multiproc * clockRate;
 
       if (compute_perf > max_compute_perf) {
         max_compute_perf = compute_perf;
@@ -808,7 +865,6 @@ inline int gpuGetMaxGflopsDeviceId() {
 
 // Initialization code to find the best CUDA Device
 inline int findCudaDevice(int argc, const char **argv) {
-  cudaDeviceProp deviceProp;
   int devID = 0;
 
   // If the command-line has a device number specified, use it
@@ -830,9 +886,12 @@ inline int findCudaDevice(int argc, const char **argv) {
     // Otherwise pick the device with highest Gflops/s
     devID = gpuGetMaxGflopsDeviceId();
     checkCudaErrors(cudaSetDevice(devID));
-    checkCudaErrors(cudaGetDeviceProperties(&deviceProp, devID));
-    printf("GPU Device %d: \"%s\" with compute capability %d.%d\n\n", devID,
-           deviceProp.name, deviceProp.major, deviceProp.minor);
+    int major = 0, minor = 0;
+    checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, devID));
+    checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, devID));
+    printf("GPU Device %d: \"%s\" with compute capability %d.%d\n\n",
+           devID, _ConvertSMVer2ArchName(major, minor), major, minor);
+
   }
 
   return devID;
@@ -843,7 +902,6 @@ inline int findIntegratedGPU() {
   int device_count = 0;
   int devices_prohibited = 0;
 
-  cudaDeviceProp deviceProp;
   checkCudaErrors(cudaGetDeviceCount(&device_count));
 
   if (device_count == 0) {
@@ -853,17 +911,19 @@ inline int findIntegratedGPU() {
 
   // Find the integrated GPU which is compute capable
   while (current_device < device_count) {
-    cudaGetDeviceProperties(&deviceProp, current_device);
-
+    int computeMode = -1, integrated = -1;
+    checkCudaErrors(cudaDeviceGetAttribute(&computeMode, cudaDevAttrComputeMode, current_device));
+    checkCudaErrors(cudaDeviceGetAttribute(&integrated, cudaDevAttrIntegrated, current_device));
     // If GPU is integrated and is not running on Compute Mode prohibited,
     // then cuda can map to GLES resource
-    if (deviceProp.integrated &&
-        (deviceProp.computeMode != cudaComputeModeProhibited)) {
+    if (integrated && (computeMode != cudaComputeModeProhibited)) {
       checkCudaErrors(cudaSetDevice(current_device));
-      checkCudaErrors(cudaGetDeviceProperties(&deviceProp, current_device));
+
+      int major = 0, minor = 0;
+      checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, current_device));
+      checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, current_device));
       printf("GPU Device %d: \"%s\" with compute capability %d.%d\n\n",
-             current_device, deviceProp.name, deviceProp.major,
-             deviceProp.minor);
+             current_device, _ConvertSMVer2ArchName(major, minor), major, minor);
 
       return current_device;
     } else {
@@ -885,19 +945,18 @@ inline int findIntegratedGPU() {
 
 // General check for CUDA GPU SM Capabilities
 inline bool checkCudaCapabilities(int major_version, int minor_version) {
-  cudaDeviceProp deviceProp;
-  deviceProp.major = 0;
-  deviceProp.minor = 0;
   int dev;
+  int major = 0, minor = 0;
 
   checkCudaErrors(cudaGetDevice(&dev));
-  checkCudaErrors(cudaGetDeviceProperties(&deviceProp, dev));
+  checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, dev));
+  checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, dev));
 
-  if ((deviceProp.major > major_version) ||
-      (deviceProp.major == major_version &&
-       deviceProp.minor >= minor_version)) {
+  if ((major > major_version) ||
+      (major == major_version &&
+       minor >= minor_version)) {
     printf("  Device %d: <%16s >, Compute SM %d.%d detected\n", dev,
-           deviceProp.name, deviceProp.major, deviceProp.minor);
+           _ConvertSMVer2ArchName(major, minor), major, minor);
     return true;
   } else {
     printf(

Common/helper_cuda_drvapi.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -33,8 +33,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <iostream>
+#include <cstring>
+#include <sstream>
 
-#include <drvapi_error_string.h>
 #include <helper_string.h>
 
 #ifndef MAX
@@ -66,48 +68,22 @@ inline int ftoi(float value) {
 // These are the inline versions for all of the SDK helper functions
 inline void __checkCudaErrors(CUresult err, const char *file, const int line) {
   if (CUDA_SUCCESS != err) {
+    const char *errorStr = NULL;
+    cuGetErrorString(err, &errorStr);
     fprintf(stderr,
             "checkCudaErrors() Driver API error = %04d \"%s\" from file <%s>, "
             "line %i.\n",
-            err, getCudaDrvErrorString(err), file, line);
+            err, errorStr, file, line);
     exit(EXIT_FAILURE);
   }
 }
 #endif
 
-#ifdef getLastCudaDrvErrorMsg
-#undef getLastCudaDrvErrorMsg
-#endif
-
-#define getLastCudaDrvErrorMsg(msg) \
-  __getLastCudaDrvErrorMsg(msg, __FILE__, __LINE__)
-
-inline void __getLastCudaDrvErrorMsg(const char *msg, const char *file,
-                                     const int line) {
-  CUresult err = cuCtxSynchronize();
-
-  if (CUDA_SUCCESS != err) {
-    fprintf(stderr, "getLastCudaDrvErrorMsg -> %s", msg);
-    fprintf(stderr,
-            "getLastCudaDrvErrorMsg -> cuCtxSynchronize API error = %04d "
-            "\"%s\" in file <%s>, line %i.\n",
-            err, getCudaDrvErrorString(err), file, line);
-    exit(EXIT_FAILURE);
-  }
-}
-
 // This function wraps the CUDA Driver API into a template function
 template <class T>
 inline void getCudaAttribute(T *attribute, CUdevice_attribute device_attribute,
                              int device) {
-  CUresult error_result =
-      cuDeviceGetAttribute(attribute, device_attribute, device);
-
-  if (error_result != CUDA_SUCCESS) {
-    printf("cuDeviceGetAttribute returned %d\n-> %s\n",
-           static_cast<int>(error_result), getCudaDrvErrorString(error_result));
-    exit(EXIT_SUCCESS);
-  }
+  checkCudaErrors(cuDeviceGetAttribute(attribute, device_attribute, device));
 }
 #endif
 
@@ -135,6 +111,11 @@ inline int _ConvertSMVer2CoresDRV(int major, int minor) {
       {0x70,  64},
       {0x72,  64},
       {0x75,  64},
+      {0x80,  64},
+      {0x86, 128},
+      {0x87, 128},
+      {0x89, 128},
+      {0x90, 128},
       {-1, -1}};
 
   int index = 0;
@@ -161,11 +142,9 @@ inline int _ConvertSMVer2CoresDRV(int major, int minor) {
 inline int gpuDeviceInitDRV(int ARGC, const char **ARGV) {
   int cuDevice = 0;
   int deviceCount = 0;
-  CUresult err = cuInit(0);
+  checkCudaErrors(cuInit(0));
 
-  if (CUDA_SUCCESS == err) {
   checkCudaErrors(cuDeviceGetCount(&deviceCount));
-  }
 
   if (deviceCount == 0) {
     fprintf(stderr, "cudaDeviceInit error: no devices supporting CUDA\n");
@@ -192,7 +171,7 @@ inline int gpuDeviceInitDRV(int ARGC, const char **ARGV) {
 
   checkCudaErrors(cuDeviceGet(&cuDevice, dev));
   char name[100];
-  cuDeviceGetName(name, 100, cuDevice);
+  checkCudaErrors(cuDeviceGetName(name, 100, cuDevice));
 
   int computeMode;
   getCudaAttribute<int>(&computeMode, CU_DEVICE_ATTRIBUTE_COMPUTE_MODE, dev);
@@ -218,7 +197,6 @@ inline int gpuGetMaxGflopsDeviceIdDRV() {
   int device_count = 0;
   int sm_per_multiproc = 0;
   unsigned long long max_compute_perf = 0;
-  int best_SM_arch = 0;
   int major = 0;
   int minor = 0;
   int multiProcessorCount;
@@ -234,19 +212,6 @@ inline int gpuGetMaxGflopsDeviceIdDRV() {
     exit(EXIT_FAILURE);
   }
 
-  // Find the best major SM Architecture GPU device
-  while (current_device < device_count) {
-    checkCudaErrors(cuDeviceGetAttribute(
-        &major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, current_device));
-    checkCudaErrors(cuDeviceGetAttribute(
-        &minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, current_device));
-    if (major > 0 && major < 9999) {
-      best_SM_arch = MAX(best_SM_arch, major);
-    }
-
-    current_device++;
-  }
-
   // Find the best CUDA capable GPU device
   current_device = 0;
 
@@ -277,18 +242,9 @@ inline int gpuGetMaxGflopsDeviceIdDRV() {
                                clockRate);
 
       if (compute_perf > max_compute_perf) {
-        // If we find GPU with SM major > 2, search only these
-        if (best_SM_arch > 2) {
-          // If our device==dest_SM_arch, choose this, or else pass
-          if (major == best_SM_arch) {
           max_compute_perf = compute_perf;
           max_perf_device = current_device;
       }
-        } else {
-          max_compute_perf = compute_perf;
-          max_perf_device = current_device;
-        }
-      }
     } else {
       devices_prohibited++;
     }
@@ -414,7 +370,39 @@ inline bool checkCudaCapabilitiesDRV(int major_version, int minor_version,
   }
 }
 #endif
+bool inline findFatbinPath(const char *module_file, std::string &module_path, char **argv, std::ostringstream &ostrm)
+{
+    char *actual_path = sdkFindFilePath(module_file, argv[0]);
+
+    if (actual_path)
+    {
+        module_path = actual_path;
+    }
+    else
+    {
+        printf("> findModulePath file not found: <%s> \n", module_file);
+        return false;
+    }
+
+    if (module_path.empty())
+    {
+        printf("> findModulePath could not find file: <%s> \n", module_file);
+        return false;
+    }
+    else
+    {
+        printf("> findModulePath found file at <%s>\n", module_path.c_str());
+        if (module_path.rfind("fatbin") != std::string::npos)
+        {
+            std::ifstream fileIn(module_path.c_str(), std::ios::binary);
+            ostrm << fileIn.rdbuf();
+            fileIn.close();
+        }
+        return true;
+    }
+}
 
   // end of CUDA Helper Functions
 
 #endif  // COMMON_HELPER_CUDA_DRVAPI_H_
+

Common/helper_cusolver.h

@@ -0,0 +1,166 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef HELPER_CUSOLVER
+#define HELPER_CUSOLVER
+
+#include <ctype.h>
+#include <cuda_runtime.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cusparse.h"
+
+#define SWITCH_CHAR '-'
+
+struct testOpts {
+  char *sparse_mat_filename;  // by switch -F<filename>
+  const char *testFunc;       // by switch -R<name>
+  const char *reorder;        // by switch -P<name>
+  int lda;                    // by switch -lda<int>
+};
+
+double vec_norminf(int n, const double *x) {
+  double norminf = 0;
+  for (int j = 0; j < n; j++) {
+    double x_abs = fabs(x[j]);
+    norminf = (norminf > x_abs) ? norminf : x_abs;
+  }
+  return norminf;
+}
+
+/*
+ * |A| = max { |A|*ones(m,1) }
+ */
+double mat_norminf(int m, int n, const double *A, int lda) {
+  double norminf = 0;
+  for (int i = 0; i < m; i++) {
+    double sum = 0.0;
+    for (int j = 0; j < n; j++) {
+      double A_abs = fabs(A[i + j * lda]);
+      sum += A_abs;
+    }
+    norminf = (norminf > sum) ? norminf : sum;
+  }
+  return norminf;
+}
+
+/*
+ * |A| = max { |A|*ones(m,1) }
+ */
+double csr_mat_norminf(int m, int n, int nnzA, const cusparseMatDescr_t descrA,
+                       const double *csrValA, const int *csrRowPtrA,
+                       const int *csrColIndA) {
+  const int baseA =
+      (CUSPARSE_INDEX_BASE_ONE == cusparseGetMatIndexBase(descrA)) ? 1 : 0;
+
+  double norminf = 0;
+  for (int i = 0; i < m; i++) {
+    double sum = 0.0;
+    const int start = csrRowPtrA[i] - baseA;
+    const int end = csrRowPtrA[i + 1] - baseA;
+    for (int colidx = start; colidx < end; colidx++) {
+      // const int j = csrColIndA[colidx] - baseA;
+      double A_abs = fabs(csrValA[colidx]);
+      sum += A_abs;
+    }
+    norminf = (norminf > sum) ? norminf : sum;
+  }
+  return norminf;
+}
+
+void display_matrix(int m, int n, int nnzA, const cusparseMatDescr_t descrA,
+                    const double *csrValA, const int *csrRowPtrA,
+                    const int *csrColIndA) {
+  const int baseA =
+      (CUSPARSE_INDEX_BASE_ONE == cusparseGetMatIndexBase(descrA)) ? 1 : 0;
+
+  printf("m = %d, n = %d, nnz = %d, matlab base-1\n", m, n, nnzA);
+
+  for (int row = 0; row < m; row++) {
+    const int start = csrRowPtrA[row] - baseA;
+    const int end = csrRowPtrA[row + 1] - baseA;
+    for (int colidx = start; colidx < end; colidx++) {
+      const int col = csrColIndA[colidx] - baseA;
+      double Areg = csrValA[colidx];
+      printf("A(%d, %d) = %20.16E\n", row + 1, col + 1, Areg);
+    }
+  }
+}
+
+#if defined(_WIN32)
+#if !defined(WIN32_LEAN_AND_MEAN)
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+double second(void) {
+  LARGE_INTEGER t;
+  static double oofreq;
+  static int checkedForHighResTimer;
+  static BOOL hasHighResTimer;
+
+  if (!checkedForHighResTimer) {
+    hasHighResTimer = QueryPerformanceFrequency(&t);
+    oofreq = 1.0 / (double)t.QuadPart;
+    checkedForHighResTimer = 1;
+  }
+  if (hasHighResTimer) {
+    QueryPerformanceCounter(&t);
+    return (double)t.QuadPart * oofreq;
+  } else {
+    return (double)GetTickCount() / 1000.0;
+  }
+}
+
+#elif defined(__linux__) || defined(__QNX__)
+#include <stddef.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+double second(void) {
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
+}
+
+#elif defined(__APPLE__)
+#include <stddef.h>
+#include <sys/resource.h>
+#include <sys/sysctl.h>
+#include <sys/time.h>
+#include <sys/types.h>
+double second(void) {
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
+}
+#else
+#error unsupported platform
+#endif
+
+#endif

Common/helper_functions.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions

Common/helper_gl.h

@@ -0,0 +1,267 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// These are helper functions for the SDK samples (OpenGL)
+#ifndef HELPER_GL_H
+#define HELPER_GL_H
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+    #include <GL/glew.h>
+#endif
+
+#if defined(__APPLE__) || defined(MACOSX)
+    #include <OpenGL/gl.h>
+#else
+    #include <GL/gl.h>
+    #ifdef __linux__
+    #include <GL/glx.h>
+    #endif /* __linux__ */
+#endif
+
+#include <iostream>
+#include <cstdio>
+#include <string>
+#include <sstream>
+#include <algorithm>
+#include <iterator>
+#include <vector>
+#include <assert.h>
+
+
+/* Prototypes */
+namespace __HelperGL {
+    static int isGLVersionSupported(unsigned reqMajor, unsigned reqMinor);
+    static int areGLExtensionsSupported(const std::string &);
+#ifdef __linux__
+
+    #ifndef HELPERGL_EXTERN_GL_FUNC_IMPLEMENTATION
+    #define USE_GL_FUNC(name, proto) proto name = (proto) glXGetProcAddress ((const GLubyte *)#name)
+    #else
+    #define USE_GL_FUNC(name, proto) extern proto name
+    #endif
+
+    USE_GL_FUNC(glBindBuffer, PFNGLBINDBUFFERPROC);
+    USE_GL_FUNC(glDeleteBuffers, PFNGLDELETEBUFFERSPROC);
+    USE_GL_FUNC(glBufferData, PFNGLBUFFERDATAPROC);
+    USE_GL_FUNC(glBufferSubData, PFNGLBUFFERSUBDATAPROC);
+    USE_GL_FUNC(glGenBuffers, PFNGLGENBUFFERSPROC);
+    USE_GL_FUNC(glCreateProgram, PFNGLCREATEPROGRAMPROC);
+    USE_GL_FUNC(glBindProgramARB, PFNGLBINDPROGRAMARBPROC);
+    USE_GL_FUNC(glGenProgramsARB, PFNGLGENPROGRAMSARBPROC);
+    USE_GL_FUNC(glDeleteProgramsARB, PFNGLDELETEPROGRAMSARBPROC);
+    USE_GL_FUNC(glDeleteProgram, PFNGLDELETEPROGRAMPROC);
+    USE_GL_FUNC(glGetProgramInfoLog, PFNGLGETPROGRAMINFOLOGPROC);
+    USE_GL_FUNC(glGetProgramiv, PFNGLGETPROGRAMIVPROC);
+    USE_GL_FUNC(glProgramParameteriEXT, PFNGLPROGRAMPARAMETERIEXTPROC);
+    USE_GL_FUNC(glProgramStringARB, PFNGLPROGRAMSTRINGARBPROC);
+    USE_GL_FUNC(glUnmapBuffer, PFNGLUNMAPBUFFERPROC);
+    USE_GL_FUNC(glMapBuffer, PFNGLMAPBUFFERPROC);
+    USE_GL_FUNC(glGetBufferParameteriv, PFNGLGETBUFFERPARAMETERIVPROC);
+    USE_GL_FUNC(glLinkProgram, PFNGLLINKPROGRAMPROC);
+    USE_GL_FUNC(glUseProgram, PFNGLUSEPROGRAMPROC);
+    USE_GL_FUNC(glAttachShader, PFNGLATTACHSHADERPROC);
+    USE_GL_FUNC(glCreateShader, PFNGLCREATESHADERPROC);
+    USE_GL_FUNC(glShaderSource, PFNGLSHADERSOURCEPROC);
+    USE_GL_FUNC(glCompileShader, PFNGLCOMPILESHADERPROC);
+    USE_GL_FUNC(glDeleteShader, PFNGLDELETESHADERPROC);
+    USE_GL_FUNC(glGetShaderInfoLog, PFNGLGETSHADERINFOLOGPROC);
+    USE_GL_FUNC(glGetShaderiv, PFNGLGETSHADERIVPROC);
+    USE_GL_FUNC(glUniform1i, PFNGLUNIFORM1IPROC);
+    USE_GL_FUNC(glUniform1f, PFNGLUNIFORM1FPROC);
+    USE_GL_FUNC(glUniform2f, PFNGLUNIFORM2FPROC);
+    USE_GL_FUNC(glUniform3f, PFNGLUNIFORM3FPROC);
+    USE_GL_FUNC(glUniform4f, PFNGLUNIFORM4FPROC);
+    USE_GL_FUNC(glUniform1fv, PFNGLUNIFORM1FVPROC);
+    USE_GL_FUNC(glUniform2fv, PFNGLUNIFORM2FVPROC);
+    USE_GL_FUNC(glUniform3fv, PFNGLUNIFORM3FVPROC);
+    USE_GL_FUNC(glUniform4fv, PFNGLUNIFORM4FVPROC);
+    USE_GL_FUNC(glUniformMatrix4fv, PFNGLUNIFORMMATRIX4FVPROC);
+    USE_GL_FUNC(glSecondaryColor3fv, PFNGLSECONDARYCOLOR3FVPROC);
+    USE_GL_FUNC(glGetUniformLocation, PFNGLGETUNIFORMLOCATIONPROC);
+    USE_GL_FUNC(glGenFramebuffersEXT, PFNGLGENFRAMEBUFFERSEXTPROC);
+    USE_GL_FUNC(glBindFramebufferEXT, PFNGLBINDFRAMEBUFFEREXTPROC);
+    USE_GL_FUNC(glDeleteFramebuffersEXT, PFNGLDELETEFRAMEBUFFERSEXTPROC);
+    USE_GL_FUNC(glCheckFramebufferStatusEXT, PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC);
+    USE_GL_FUNC(glGetFramebufferAttachmentParameterivEXT, PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC);
+    USE_GL_FUNC(glFramebufferTexture1DEXT, PFNGLFRAMEBUFFERTEXTURE1DEXTPROC);
+    USE_GL_FUNC(glFramebufferTexture2DEXT, PFNGLFRAMEBUFFERTEXTURE2DEXTPROC);
+    USE_GL_FUNC(glFramebufferTexture3DEXT, PFNGLFRAMEBUFFERTEXTURE3DEXTPROC);
+    USE_GL_FUNC(glGenerateMipmapEXT, PFNGLGENERATEMIPMAPEXTPROC);
+    USE_GL_FUNC(glGenRenderbuffersEXT, PFNGLGENRENDERBUFFERSEXTPROC);
+    USE_GL_FUNC(glDeleteRenderbuffersEXT, PFNGLDELETERENDERBUFFERSEXTPROC);
+    USE_GL_FUNC(glBindRenderbufferEXT, PFNGLBINDRENDERBUFFEREXTPROC);
+    USE_GL_FUNC(glRenderbufferStorageEXT, PFNGLRENDERBUFFERSTORAGEEXTPROC);
+    USE_GL_FUNC(glFramebufferRenderbufferEXT, PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC);
+    USE_GL_FUNC(glClampColorARB, PFNGLCLAMPCOLORARBPROC);
+    USE_GL_FUNC(glBindFragDataLocationEXT, PFNGLBINDFRAGDATALOCATIONEXTPROC);
+
+#if !defined(GLX_EXTENSION_NAME) || !defined(GL_VERSION_1_3)
+    USE_GL_FUNC(glActiveTexture, PFNGLACTIVETEXTUREPROC);
+    USE_GL_FUNC(glClientActiveTexture, PFNGLACTIVETEXTUREPROC);
+#endif
+
+    #undef USE_GL_FUNC
+#endif /*__linux__ */
+}
+
+
+namespace __HelperGL {
+    namespace __Int {
+        static std::vector<std::string> split(const std::string &str)
+        {
+            std::istringstream ss(str);
+            std::istream_iterator<std::string> it(ss);
+            return std::vector<std::string> (it, std::istream_iterator<std::string>());
+        }
+
+        /* Sort the vector passed by reference */
+        template<typename T> static inline void sort(std::vector<T> &a)
+        {
+            std::sort(a.begin(), a.end());
+        }
+
+        /* Compare two vectors */
+        template<typename T> static int equals(std::vector<T> a, std::vector<T> b)
+        {
+            if (a.size() != b.size()) return 0;
+            sort(a);
+            sort(b);
+
+            return std::equal(a.begin(), a.end(), b.begin());
+        }
+
+        template<typename T> static std::vector<T> getIntersection(std::vector<T> a, std::vector<T> b)
+        {
+            sort(a);
+            sort(b);
+
+            std::vector<T> rc;
+            std::set_intersection(a.begin(), a.end(), b.begin(), b.end(),
+                             std::back_inserter<std::vector<std::string> >(rc));
+            return rc;
+        }
+
+        static std::vector<std::string> getGLExtensions()
+        {
+            std::string extensionsStr( (const char *)glGetString(GL_EXTENSIONS));
+            return split (extensionsStr);
+        }
+    }
+
+    static int areGLExtensionsSupported(const std::string &extensions)
+    {
+        std::vector<std::string> all = __Int::getGLExtensions();
+
+        std::vector<std::string> requested = __Int::split(extensions);
+        std::vector<std::string> matched = __Int::getIntersection(all, requested);
+
+        return __Int::equals(matched, requested);
+    }
+
+    static int isGLVersionSupported(unsigned reqMajor, unsigned reqMinor)
+    {
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+        if (glewInit() != GLEW_OK)
+        {
+            std::cerr << "glewInit() failed!" << std::endl;
+            return 0;
+        }
+#endif
+        std::string version ((const char *) glGetString (GL_VERSION));
+        std::stringstream stream (version);
+        unsigned major, minor;
+        char dot;
+
+        stream >> major >> dot >> minor;
+
+        assert (dot == '.');
+        return major > reqMajor || (major == reqMajor && minor >= reqMinor);
+    }
+
+    static inline const char* glErrorToString(GLenum err)
+    {
+#define CASE_RETURN_MACRO(arg) case arg: return #arg
+        switch(err)
+        {
+            CASE_RETURN_MACRO(GL_NO_ERROR);
+            CASE_RETURN_MACRO(GL_INVALID_ENUM);
+            CASE_RETURN_MACRO(GL_INVALID_VALUE);
+            CASE_RETURN_MACRO(GL_INVALID_OPERATION);
+            CASE_RETURN_MACRO(GL_OUT_OF_MEMORY);
+            CASE_RETURN_MACRO(GL_STACK_UNDERFLOW);
+            CASE_RETURN_MACRO(GL_STACK_OVERFLOW);
+#ifdef GL_INVALID_FRAMEBUFFER_OPERATION
+            CASE_RETURN_MACRO(GL_INVALID_FRAMEBUFFER_OPERATION);
+#endif
+            default: break;
+        }
+#undef CASE_RETURN_MACRO
+        return "*UNKNOWN*";
+    }
+
+////////////////////////////////////////////////////////////////////////////
+//! Check for OpenGL error
+//! @return bool if no GL error has been encountered, otherwise 0
+//! @param file  __FILE__ macro
+//! @param line  __LINE__ macro
+//! @note The GL error is listed on stderr
+//! @note This function should be used via the CHECK_ERROR_GL() macro
+////////////////////////////////////////////////////////////////////////////
+    inline bool sdkCheckErrorGL(const char *file, const int line)
+    {
+        bool ret_val = true;
+
+        // check for error
+        GLenum gl_error = glGetError();
+
+        if (gl_error != GL_NO_ERROR)
+        {
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+            char tmpStr[512];
+            // NOTE: "%s(%i) : " allows Visual Studio to directly jump to the file at the right line
+            // when the user double clicks on the error line in the Output pane. Like any compile error.
+            sprintf_s(tmpStr, 255, "\n%s(%i) : GL Error : %s\n\n", file, line, glErrorToString(gl_error));
+            fprintf(stderr, "%s", tmpStr);
+#endif
+            fprintf(stderr, "GL Error in file '%s' in line %d :\n", file, line);
+            fprintf(stderr, "%s\n", glErrorToString(gl_error));
+            ret_val = false;
+        }
+
+        return ret_val;
+    }
+
+#define SDK_CHECK_ERROR_GL()                                              \
+    if( false == sdkCheckErrorGL( __FILE__, __LINE__)) {                  \
+        exit(EXIT_FAILURE);                                               \
+    }                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           
+
+} /* of namespace __HelperGL*/
+
+using namespace __HelperGL;
+
+#endif /*HELPER_GL_H*/

Common/helper_image.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions

Common/helper_multiprocess.cpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -29,16 +29,11 @@
 #include <cstdlib>
 #include <string>
 
-int sharedMemoryCreate(const char *name, size_t sz, sharedMemoryInfo *info)
-{
+int sharedMemoryCreate(const char *name, size_t sz, sharedMemoryInfo *info) {
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
   info->size = sz;
-    info->shmHandle = CreateFileMapping(INVALID_HANDLE_VALUE,
-                                        NULL,
-                                        PAGE_READWRITE,
-                                        0,
-                                        (DWORD)sz,
-                                        name);
+  info->shmHandle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,
+                                      PAGE_READWRITE, 0, (DWORD)sz, name);
   if (info->shmHandle == 0) {
     return GetLastError();
   }
@@ -73,8 +68,7 @@ int sharedMemoryCreate(const char *name, size_t sz, sharedMemoryInfo *info)
 #endif
 }
 
-int sharedMemoryOpen(const char *name, size_t sz, sharedMemoryInfo *info)
-{
+int sharedMemoryOpen(const char *name, size_t sz, sharedMemoryInfo *info) {
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
   info->size = sz;
 
@@ -106,8 +100,7 @@ int sharedMemoryOpen(const char *name, size_t sz, sharedMemoryInfo *info)
 #endif
 }
 
-void sharedMemoryClose(sharedMemoryInfo *info)
-{
+void sharedMemoryClose(sharedMemoryInfo *info) {
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
   if (info->addr) {
     UnmapViewOfFile(info->addr);
@@ -125,8 +118,7 @@ void sharedMemoryClose(sharedMemoryInfo *info)
 #endif
 }
 
-int spawnProcess(Process *process, const char *app, char * const *args)
-{
+int spawnProcess(Process *process, const char *app, char *const *args) {
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
   STARTUPINFO si = {0};
   BOOL status;
@@ -140,7 +132,8 @@ int spawnProcess(Process *process, const char *app, char * const *args)
     args++;
   }
 
-    status = CreateProcess(app, LPSTR(arg_string.c_str()), NULL, NULL, FALSE, 0, NULL, NULL, &si, process);
+  status = CreateProcess(app, LPSTR(arg_string.c_str()), NULL, NULL, FALSE, 0,
+                         NULL, NULL, &si, process);
 
   return status ? 0 : GetLastError();
 #else
@@ -149,16 +142,14 @@ int spawnProcess(Process *process, const char *app, char * const *args)
     if (0 > execvp(app, args)) {
       return errno;
     }
-    }
-    else if (*process < 0) {
+  } else if (*process < 0) {
     return errno;
   }
   return 0;
 #endif
 }
 
-int waitProcess(Process *process)
-{
+int waitProcess(Process *process) {
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
   DWORD exitCode;
   WaitForSingleObject(process->hProcess, INFINITE);
@@ -176,3 +167,389 @@ int waitProcess(Process *process)
   return WEXITSTATUS(status);
 #endif
 }
+
+#if defined(__linux__) || defined(__QNX__)
+int ipcCreateSocket(ipcHandle *&handle, const char *name,
+                    const std::vector<Process> &processes) {
+  int server_fd;
+  struct sockaddr_un servaddr;
+
+  handle = new ipcHandle;
+  memset(handle, 0, sizeof(*handle));
+  handle->socket = -1;
+  handle->socketName = NULL;
+
+  // Creating socket file descriptor
+  if ((server_fd = socket(AF_UNIX, SOCK_DGRAM, 0)) == 0) {
+    perror("IPC failure: Socket creation failed");
+    return -1;
+  }
+
+  unlink(name);
+  bzero(&servaddr, sizeof(servaddr));
+  servaddr.sun_family = AF_UNIX;
+
+  size_t len = strlen(name);
+  if (len > (sizeof(servaddr.sun_path) - 1)) {
+    perror("IPC failure: Cannot bind provided name to socket. Name too large");
+    return -1;
+  }
+
+  strncpy(servaddr.sun_path, name, len);
+
+  if (bind(server_fd, (struct sockaddr *)&servaddr, SUN_LEN(&servaddr)) < 0) {
+    perror("IPC failure: Binding socket failed");
+    return -1;
+  }
+
+  handle->socketName = new char[strlen(name) + 1];
+  strcpy(handle->socketName, name);
+  handle->socket = server_fd;
+  return 0;
+}
+
+int ipcOpenSocket(ipcHandle *&handle) {
+  int sock = 0;
+  struct sockaddr_un cliaddr;
+
+  handle = new ipcHandle;
+  memset(handle, 0, sizeof(*handle));
+
+  if ((sock = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
+    perror("IPC failure:Socket creation error");
+    return -1;
+  }
+
+  bzero(&cliaddr, sizeof(cliaddr));
+  cliaddr.sun_family = AF_UNIX;
+  char temp[10];
+
+  // Create unique name for the socket.
+  sprintf(temp, "%u", getpid());
+
+  strcpy(cliaddr.sun_path, temp);
+  if (bind(sock, (struct sockaddr *)&cliaddr, sizeof(cliaddr)) < 0) {
+    perror("IPC failure: Binding socket failed");
+    return -1;
+  }
+
+  handle->socket = sock;
+  handle->socketName = new char[strlen(temp) + 1];
+  strcpy(handle->socketName, temp);
+
+  return 0;
+}
+
+int ipcCloseSocket(ipcHandle *handle) {
+  if (!handle) {
+    return -1;
+  }
+
+  if (handle->socketName) {
+    unlink(handle->socketName);
+    delete[] handle->socketName;
+  }
+  close(handle->socket);
+  delete handle;
+  return 0;
+}
+
+int ipcRecvShareableHandle(ipcHandle *handle, ShareableHandle *shHandle) {
+  struct msghdr msg = {0};
+  struct iovec iov[1];
+  struct cmsghdr cm;
+
+  // Union to guarantee alignment requirements for control array
+  union {
+    struct cmsghdr cm;
+    // This will not work on QNX as QNX CMSG_SPACE calls __cmsg_alignbytes
+    // And __cmsg_alignbytes is a runtime function instead of compile-time macros
+    // char control[CMSG_SPACE(sizeof(int))]
+    char* control;
+  } control_un;
+
+  size_t sizeof_control = CMSG_SPACE(sizeof(int)) * sizeof(char);
+  control_un.control = (char*) malloc(sizeof_control);
+  struct cmsghdr *cmptr;
+  ssize_t n;
+  int receivedfd;
+  char dummy_buffer[1];
+  ssize_t sendResult;
+  msg.msg_control = control_un.control;
+  msg.msg_controllen = sizeof_control;
+
+  iov[0].iov_base = (void *)dummy_buffer;
+  iov[0].iov_len = sizeof(dummy_buffer);
+
+  msg.msg_iov = iov;
+  msg.msg_iovlen = 1;
+  if ((n = recvmsg(handle->socket, &msg, 0)) <= 0) {
+    perror("IPC failure: Receiving data over socket failed");
+    free(control_un.control);
+    return -1;
+  }
+
+  if (((cmptr = CMSG_FIRSTHDR(&msg)) != NULL) &&
+      (cmptr->cmsg_len == CMSG_LEN(sizeof(int)))) {
+    if ((cmptr->cmsg_level != SOL_SOCKET) || (cmptr->cmsg_type != SCM_RIGHTS)) {
+      free(control_un.control);
+      return -1;
+    }
+
+    memmove(&receivedfd, CMSG_DATA(cmptr), sizeof(receivedfd));
+    *(int *)shHandle = receivedfd;
+  } else {
+    free(control_un.control);
+    return -1;
+  }
+
+  free(control_un.control);
+  return 0;
+}
+
+int ipcRecvDataFromClient(ipcHandle *serverHandle, void *data, size_t size) {
+  ssize_t readResult;
+  struct sockaddr_un cliaddr;
+  socklen_t len = sizeof(cliaddr);
+
+  readResult = recvfrom(serverHandle->socket, data, size, 0,
+                        (struct sockaddr *)&cliaddr, &len);
+  if (readResult == -1) {
+    perror("IPC failure: Receiving data over socket failed");
+    return -1;
+  }
+  return 0;
+}
+
+int ipcSendDataToServer(ipcHandle *handle, const char *serverName,
+                        const void *data, size_t size) {
+  ssize_t sendResult;
+  struct sockaddr_un serveraddr;
+
+  bzero(&serveraddr, sizeof(serveraddr));
+  serveraddr.sun_family = AF_UNIX;
+  strncpy(serveraddr.sun_path, serverName, sizeof(serveraddr.sun_path) - 1);
+
+  sendResult = sendto(handle->socket, data, size, 0,
+                      (struct sockaddr *)&serveraddr, sizeof(serveraddr));
+  if (sendResult <= 0) {
+    perror("IPC failure: Sending data over socket failed");
+  }
+
+  return 0;
+}
+
+int ipcSendShareableHandle(ipcHandle *handle,
+                           const std::vector<ShareableHandle> &shareableHandles,
+                           Process process, int data) {
+  struct msghdr msg;
+  struct iovec iov[1];
+
+  union {
+    struct cmsghdr cm;
+    char* control;
+  } control_un;
+
+  size_t sizeof_control = CMSG_SPACE(sizeof(int)) * sizeof(char);
+  control_un.control = (char*) malloc(sizeof_control);
+
+  struct cmsghdr *cmptr;
+  ssize_t readResult;
+  struct sockaddr_un cliaddr;
+  socklen_t len = sizeof(cliaddr);
+
+  // Construct client address to send this SHareable handle to
+  bzero(&cliaddr, sizeof(cliaddr));
+  cliaddr.sun_family = AF_UNIX;
+  char temp[10];
+  sprintf(temp, "%u", process);
+  strcpy(cliaddr.sun_path, temp);
+  len = sizeof(cliaddr);
+
+  // Send corresponding shareable handle to the client
+  int sendfd = (int)shareableHandles[data];
+
+  msg.msg_control = control_un.control;
+  msg.msg_controllen = sizeof_control;
+
+  cmptr = CMSG_FIRSTHDR(&msg);
+  cmptr->cmsg_len = CMSG_LEN(sizeof(int));
+  cmptr->cmsg_level = SOL_SOCKET;
+  cmptr->cmsg_type = SCM_RIGHTS;
+
+  memmove(CMSG_DATA(cmptr), &sendfd, sizeof(sendfd));
+
+  msg.msg_name = (void *)&cliaddr;
+  msg.msg_namelen = sizeof(struct sockaddr_un);
+
+  iov[0].iov_base = (void *)"";
+  iov[0].iov_len = 1;
+  msg.msg_iov = iov;
+  msg.msg_iovlen = 1;
+
+  ssize_t sendResult = sendmsg(handle->socket, &msg, 0);
+  if (sendResult <= 0) {
+    perror("IPC failure: Sending data over socket failed");
+    free(control_un.control);
+    return -1;
+  }
+
+  free(control_un.control);
+  return 0;
+}
+
+int ipcSendShareableHandles(
+    ipcHandle *handle, const std::vector<ShareableHandle> &shareableHandles,
+    const std::vector<Process> &processes) {
+  // Send all shareable handles to every single process.
+  for (int i = 0; i < shareableHandles.size(); i++) {
+    for (int j = 0; j < processes.size(); j++) {
+      checkIpcErrors(
+          ipcSendShareableHandle(handle, shareableHandles, processes[j], i));
+    }
+  }
+  return 0;
+}
+
+int ipcRecvShareableHandles(ipcHandle *handle,
+                            std::vector<ShareableHandle> &shareableHandles) {
+  for (int i = 0; i < shareableHandles.size(); i++) {
+    checkIpcErrors(ipcRecvShareableHandle(handle, &shareableHandles[i]));
+  }
+  return 0;
+}
+
+int ipcCloseShareableHandle(ShareableHandle shHandle) {
+  return close(shHandle);
+}
+
+#elif defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+// Generic name to build individual Mailslot names by appending process ids.
+LPTSTR SlotName = (LPTSTR)TEXT("\\\\.\\mailslot\\sample_mailslot_");
+
+int ipcCreateSocket(ipcHandle *&handle, const char *name,
+                    const std::vector<Process> &processes) {
+  handle = new ipcHandle;
+  handle->hMailslot.resize(processes.size());
+
+  // Open Mailslots of all clients and store respective handles.
+  for (int i = 0; i < handle->hMailslot.size(); ++i) {
+    std::basic_string<TCHAR> childSlotName(SlotName);
+    char tempBuf[20];
+    _itoa_s(processes[i].dwProcessId, tempBuf, 10);
+    childSlotName += TEXT(tempBuf);
+
+    HANDLE hFile =
+        CreateFile(TEXT(childSlotName.c_str()), GENERIC_WRITE, FILE_SHARE_READ,
+                   (LPSECURITY_ATTRIBUTES)NULL, OPEN_EXISTING,
+                   FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL);
+    if (hFile == INVALID_HANDLE_VALUE) {
+      printf("IPC failure: Opening Mailslot by CreateFile failed with %d\n",
+             GetLastError());
+      return -1;
+    }
+    handle->hMailslot[i] = hFile;
+  }
+  return 0;
+}
+
+int ipcOpenSocket(ipcHandle *&handle) {
+  handle = new ipcHandle;
+  HANDLE hSlot;
+
+  std::basic_string<TCHAR> clientSlotName(SlotName);
+  char tempBuf[20];
+  _itoa_s(GetCurrentProcessId(), tempBuf, 10);
+  clientSlotName += TEXT(tempBuf);
+
+  hSlot = CreateMailslot((LPSTR)clientSlotName.c_str(), 0,
+                         MAILSLOT_WAIT_FOREVER, (LPSECURITY_ATTRIBUTES)NULL);
+  if (hSlot == INVALID_HANDLE_VALUE) {
+    printf("IPC failure: CreateMailslot failed for client with %d\n",
+           GetLastError());
+    return -1;
+  }
+
+  handle->hMailslot.push_back(hSlot);
+  return 0;
+}
+
+int ipcSendData(HANDLE mailslot, const void *data, size_t sz) {
+  BOOL result;
+  DWORD cbWritten;
+
+  result = WriteFile(mailslot, data, (DWORD)sz, &cbWritten, (LPOVERLAPPED)NULL);
+  if (!result) {
+    printf("IPC failure: WriteFile failed with %d.\n", GetLastError());
+    return -1;
+  }
+  return 0;
+}
+
+int ipcRecvData(ipcHandle *handle, void *data, size_t sz) {
+  DWORD cbRead = 0;
+
+  if (!ReadFile(handle->hMailslot[0], data, (DWORD)sz, &cbRead, NULL)) {
+    printf("IPC failure: ReadFile failed with %d.\n", GetLastError());
+    return -1;
+  }
+
+  if (sz != (size_t)cbRead) {
+    printf(
+        "IPC failure: ReadFile didn't receive the expected number of bytes\n");
+    return -1;
+  }
+
+  return 0;
+}
+
+int ipcSendShareableHandles(
+    ipcHandle *handle, const std::vector<ShareableHandle> &shareableHandles,
+    const std::vector<Process> &processes) {
+  // Send all shareable handles to every single process.
+  for (int i = 0; i < processes.size(); i++) {
+    HANDLE hProcess =
+        OpenProcess(PROCESS_DUP_HANDLE, FALSE, processes[i].dwProcessId);
+    if (hProcess == INVALID_HANDLE_VALUE) {
+      printf("IPC failure: OpenProcess failed (%d)\n", GetLastError());
+      return -1;
+    }
+
+    for (int j = 0; j < shareableHandles.size(); j++) {
+      HANDLE hDup = INVALID_HANDLE_VALUE;
+      // Duplicate the handle into the target process's space
+      if (!DuplicateHandle(GetCurrentProcess(), shareableHandles[j], hProcess,
+                           &hDup, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
+        printf("IPC failure: DuplicateHandle failed (%d)\n", GetLastError());
+        return -1;
+      }
+      checkIpcErrors(ipcSendData(handle->hMailslot[i], &hDup, sizeof(hDup)));
+    }
+    CloseHandle(hProcess);
+  }
+  return 0;
+}
+
+int ipcRecvShareableHandles(ipcHandle *handle,
+                            std::vector<ShareableHandle> &shareableHandles) {
+  for (int i = 0; i < shareableHandles.size(); i++) {
+    checkIpcErrors(
+        ipcRecvData(handle, &shareableHandles[i], sizeof(shareableHandles[i])));
+  }
+  return 0;
+}
+
+int ipcCloseSocket(ipcHandle *handle) {
+  for (int i = 0; i < handle->hMailslot.size(); i++) {
+    CloseHandle(handle->hMailslot[i]);
+  }
+  delete handle;
+  return 0;
+}
+
+int ipcCloseShareableHandle(ShareableHandle shHandle) {
+  CloseHandle(shHandle);
+  return 0;
+}
+
+#endif

Common/helper_multiprocess.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -33,13 +33,26 @@
 #define WIN32_LEAN_AND_MEAN
 #endif
 #include <windows.h>
+#include <iostream>
+#include <stdio.h>
+#include <tchar.h>
+#include <strsafe.h>
+#include <sddl.h>
+#include <aclapi.h>
+#include <winternl.h>
 #else
+#include <stdio.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sys/wait.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <memory.h>
+#include <sys/un.h>
 #endif
+#include <vector>
 
 typedef struct sharedMemoryInfo_st {
     void *addr;
@@ -68,4 +81,40 @@ int spawnProcess(Process *process, const char *app, char * const *args);
 
 int waitProcess(Process *process);
 
+#define checkIpcErrors(ipcFuncResult) \
+    if (ipcFuncResult == -1) { fprintf(stderr, "Failure at %u %s\n", __LINE__, __FILE__); exit(EXIT_FAILURE); }
+
+#if defined(__linux__) || defined(__QNX__)
+struct ipcHandle_st {
+    int socket;
+    char *socketName;
+};
+typedef int ShareableHandle;
+#elif defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+struct ipcHandle_st {
+    std::vector<HANDLE> hMailslot; // 1 Handle in case of child and `num children` Handles for parent.
+};
+typedef HANDLE ShareableHandle;
+#endif
+
+typedef struct ipcHandle_st ipcHandle;
+
+int
+ipcCreateSocket(ipcHandle *&handle, const char *name, const std::vector<Process>& processes);
+
+int
+ipcOpenSocket(ipcHandle *&handle);
+
+int
+ipcCloseSocket(ipcHandle *handle);
+
+int
+ipcRecvShareableHandles(ipcHandle *handle, std::vector<ShareableHandle>& shareableHandles);
+
+int
+ipcSendShareableHandles(ipcHandle *handle, const std::vector<ShareableHandle>& shareableHandles, const std::vector<Process>& processes);
+
+int
+ipcCloseShareableHandle(ShareableHandle shHandle);
+
 #endif // HELPER_MULTIPROCESS_H

Common/helper_nvJPEG.hxx

@@ -1,4 +1,4 @@
-/* Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -25,12 +25,16 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-// This sample needs at least CUDA 10.0.
+// This sample needs at least CUDA 10.1.
 // It demonstrates usages of the nvJPEG library
 
 #ifndef NV_JPEG_EXAMPLE
 #define NV_JPEG_EXAMPLE
 
+#ifdef _WIN64
+#include <windows.h>
+#endif
+
 #include "cuda_runtime.h"
 #include "nvjpeg.h"
 #include "helper_cuda.h"
@@ -44,12 +48,14 @@
 #include <vector>
 
 #include <string.h>  // strcmpi
+#ifndef _WIN64
 #include <sys/time.h>  // timings
 
 #include <dirent.h>  // linux dir traverse
+#include <unistd.h>
+#endif
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <unistd.h>
 
 // write bmp, input - RGB, device
 int writeBMP(const char *filename, const unsigned char *d_chanR, int pitchR,
@@ -291,9 +297,23 @@ int writeBMPi(const char *filename, const unsigned char *d_RGB, int pitch,
   return 0;
 }
 
+int inputDirExists(const char *pathname) {
+  struct stat info;
+  if (stat(pathname, &info) != 0) {
+    return 0;  // Directory does not exists
+  } else if (info.st_mode & S_IFDIR) {
+    // is a directory
+    return 1;
+  } else {
+    // is not a directory
+    return 0;
+  }
+}
+
 int readInput(const std::string &sInputPath,
               std::vector<std::string> &filelist) {
   int error_code = 1;
+#ifndef _WIN64
   struct stat s;
 
   if (stat(sInputPath.c_str(), &s) == 0) {
@@ -308,15 +328,18 @@ int readInput(const std::string &sInputPath,
       if (dir_handle) {
         error_code = 0;
         while ((dir = readdir(dir_handle)) != NULL) {
-          if (dir->d_type == DT_REG) {
           std::string sFileName = sInputPath + dir->d_name;
-            filelist.push_back(sFileName);
-          } else if (dir->d_type == DT_DIR) {
+          if (inputDirExists(sFileName.c_str()))
+          {
             std::string sname = dir->d_name;
             if (sname != "." && sname != "..") {
               readInput(sInputPath + sname + "/", filelist);
             }
           }
+          else
+          {
+            filelist.push_back(sFileName);
+          }
         }
         closedir(dir_handle);
       } else {
@@ -331,8 +354,75 @@ int readInput(const std::string &sInputPath,
     std::cout << "Cannot find input path " << sInputPath << std::endl;
     return error_code;
   }
-
+#else
+  std::string search_path = sInputPath + "/*.*";
+  WIN32_FIND_DATA fd;
+  HANDLE hFind = ::FindFirstFile(search_path.c_str(), &fd);
+  if (hFind != INVALID_HANDLE_VALUE) {
+    do {
+      // read all (real) files in current folder
+      // , delete '!' read other 2 default folder . and ..
+      if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
+        std::string temp(sInputPath + "\\" + fd.cFileName);
+        filelist.push_back(temp);
+      }
+    } while (::FindNextFile(hFind, &fd));
+    ::FindClose(hFind);
+  } else {
+    std::cout << "Cannot open input directory: " << sInputPath << std::endl;
+    return error_code;
+  }
+#endif
   return 0;
 }
 
+
+int getInputDir(std::string &input_dir, const char *executable_path) {
+  int found = 0;
+  if (executable_path != 0) {
+    std::string executable_name = std::string(executable_path);
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+    // Windows path delimiter
+    size_t delimiter_pos = executable_name.find_last_of('\\');
+    executable_name.erase(0, delimiter_pos + 1);
+
+    if (executable_name.rfind(".exe") != std::string::npos) {
+      // we strip .exe, only if the .exe is found
+      executable_name.resize(executable_name.size() - 4);
+    }
+#else
+    // Linux & OSX path delimiter
+    size_t delimiter_pos = executable_name.find_last_of('/');
+    executable_name.erase(0, delimiter_pos + 1);
+#endif
+
+    // Search in default paths for input images.
+    std::string pathname = "";
+    const char *searchPath[] = {
+        "./images",
+        "../../../../Samples/4_CUDA_Libraries/<executable_name>/images",
+        "../../../Samples/4_CUDA_Libraries/<executable_name>/images",
+        "../../Samples/4_CUDA_Libraries/<executable_name>/images"};
+
+    for (unsigned int i = 0; i < sizeof(searchPath) / sizeof(char *); ++i) {
+      std::string pathname(searchPath[i]);
+      size_t executable_name_pos = pathname.find("<executable_name>");
+
+      // If there is executable_name variable in the searchPath
+      // replace it with the value
+      if (executable_name_pos != std::string::npos) {
+        pathname.replace(executable_name_pos, strlen("<executable_name>"),
+                         executable_name);
+      }
+
+      if (inputDirExists(pathname.c_str())) {
+        input_dir = pathname + "/";
+        found = 1;
+        break;
+      }
+    }
+  }
+  return found;
+}
+
 #endif

Common/helper_string.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -287,12 +287,74 @@ inline char *sdkFindFilePath(const char *filename,
   const char *searchPath[] = {
       "./",                                           // same dir
       "./data/",                                      // same dir
+
       "../../../../Samples/<executable_name>/",       // up 4 in tree
       "../../../Samples/<executable_name>/",          // up 3 in tree
       "../../Samples/<executable_name>/",             // up 2 in tree
+
       "../../../../Samples/<executable_name>/data/",  // up 4 in tree
       "../../../Samples/<executable_name>/data/",     // up 3 in tree
       "../../Samples/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../Samples/0_Introduction/<executable_name>/",  // up 4 in tree
+      "../../../Samples/0_Introduction/<executable_name>/",     // up 3 in tree
+      "../../Samples/0_Introduction/<executable_name>/",        // up 2 in tree
+
+      "../../../../Samples/1_Utilities/<executable_name>/",  // up 4 in tree
+      "../../../Samples/1_Utilities/<executable_name>/",     // up 3 in tree
+      "../../Samples/1_Utilities/<executable_name>/",        // up 2 in tree
+
+      "../../../../Samples/2_Concepts_and_Techniques/<executable_name>/",  // up 4 in tree
+      "../../../Samples/2_Concepts_and_Techniques/<executable_name>/",     // up 3 in tree
+      "../../Samples/2_Concepts_and_Techniques/<executable_name>/",        // up 2 in tree
+
+      "../../../../Samples/3_CUDA_Features/<executable_name>/",  // up 4 in tree
+      "../../../Samples/3_CUDA_Features/<executable_name>/",     // up 3 in tree
+      "../../Samples/3_CUDA_Features/<executable_name>/",        // up 2 in tree
+
+      "../../../../Samples/4_CUDA_Libraries/<executable_name>/",  // up 4 in tree
+      "../../../Samples/4_CUDA_Libraries/<executable_name>/",     // up 3 in tree
+      "../../Samples/4_CUDA_Libraries/<executable_name>/",        // up 2 in tree
+
+      "../../../../Samples/5_Domain_Specific/<executable_name>/",  // up 4 in tree
+      "../../../Samples/5_Domain_Specific/<executable_name>/",     // up 3 in tree
+      "../../Samples/5_Domain_Specific/<executable_name>/",        // up 2 in tree
+
+      "../../../../Samples/6_Performance/<executable_name>/",  // up 4 in tree
+      "../../../Samples/6_Performance/<executable_name>/",     // up 3 in tree
+      "../../Samples/6_Performance/<executable_name>/",        // up 2 in tree
+
+      "../../../../Samples/0_Introduction/<executable_name>/data/",  // up 4 in tree
+      "../../../Samples/0_Introduction/<executable_name>/data/",     // up 3 in tree
+      "../../Samples/0_Introduction/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../Samples/1_Utilities/<executable_name>/data/",  // up 4 in tree
+      "../../../Samples/1_Utilities/<executable_name>/data/",     // up 3 in tree
+      "../../Samples/1_Utilities/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../Samples/2_Concepts_and_Techniques/<executable_name>/data/",  // up 4 in tree
+      "../../../Samples/2_Concepts_and_Techniques/<executable_name>/data/",     // up 3 in tree
+      "../../Samples/2_Concepts_and_Techniques/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../Samples/3_CUDA_Features/<executable_name>/data/",  // up 4 in tree
+      "../../../Samples/3_CUDA_Features/<executable_name>/data/",     // up 3 in tree
+      "../../Samples/3_CUDA_Features/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../Samples/4_CUDA_Libraries/<executable_name>/data/",  // up 4 in tree
+      "../../../Samples/4_CUDA_Libraries/<executable_name>/data/",     // up 3 in tree
+      "../../Samples/4_CUDA_Libraries/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../Samples/5_Domain_Specific/<executable_name>/data/",  // up 4 in tree
+      "../../../Samples/5_Domain_Specific/<executable_name>/data/",     // up 3 in tree
+      "../../Samples/5_Domain_Specific/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../Samples/6_Performance/<executable_name>/data/",  // up 4 in tree
+      "../../../Samples/6_Performance/<executable_name>/data/",     // up 3 in tree
+      "../../Samples/6_Performance/<executable_name>/data/",        // up 2 in tree
+
+      "../../../../Common/data/",                     // up 4 in tree
+      "../../../Common/data/",                        // up 3 in tree
+      "../../Common/data/"                            // up 2 in tree
   };
 
   // Extract the executable name
@@ -359,6 +421,7 @@ inline char *sdkFindFilePath(const char *filename,
   }
 
   // File not found
+  printf("\nerror: sdkFindFilePath: file <%s> not found!\n", filename);
   return 0;
 }
 

Common/helper_timer.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions

Common/multithreading.cpp

@@ -0,0 +1,78 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <multithreading.h>
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+// Create thread
+CUTThread cutStartThread(CUT_THREADROUTINE func, void *data) {
+  return CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)func, data, 0, NULL);
+}
+
+// Wait for thread to finish
+void cutEndThread(CUTThread thread) {
+  WaitForSingleObject(thread, INFINITE);
+  CloseHandle(thread);
+}
+
+// Destroy thread
+void cutDestroyThread(CUTThread thread) {
+  TerminateThread(thread, 0);
+  CloseHandle(thread);
+}
+
+// Wait for multiple threads
+void cutWaitForThreads(const CUTThread *threads, int num) {
+  WaitForMultipleObjects(num, threads, true, INFINITE);
+
+  for (int i = 0; i < num; i++) {
+    CloseHandle(threads[i]);
+  }
+}
+
+#else
+// Create thread
+CUTThread cutStartThread(CUT_THREADROUTINE func, void *data) {
+  pthread_t thread;
+  pthread_create(&thread, NULL, func, data);
+  return thread;
+}
+
+// Wait for thread to finish
+void cutEndThread(CUTThread thread) { pthread_join(thread, NULL); }
+
+// Destroy thread
+void cutDestroyThread(CUTThread thread) { pthread_cancel(thread); }
+
+// Wait for multiple threads
+void cutWaitForThreads(const CUTThread *threads, int num) {
+  for (int i = 0; i < num; i++) {
+    cutEndThread(threads[i]);
+  }
+}
+
+#endif

Common/multithreading.h

@@ -0,0 +1,76 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MULTITHREADING_H
+#define MULTITHREADING_H
+
+
+//Simple portable thread library.
+
+//Windows threads.
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+#include <windows.h>
+
+typedef HANDLE CUTThread;
+typedef unsigned(WINAPI *CUT_THREADROUTINE)(void *);
+
+#define CUT_THREADPROC unsigned WINAPI
+#define  CUT_THREADEND return 0
+
+#else
+//POSIX threads.
+#include <pthread.h>
+
+typedef pthread_t CUTThread;
+typedef void *(*CUT_THREADROUTINE)(void *);
+
+#define CUT_THREADPROC void
+#define  CUT_THREADEND
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//Create thread.
+CUTThread cutStartThread(CUT_THREADROUTINE, void *data);
+
+//Wait for thread to finish.
+void cutEndThread(CUTThread thread);
+
+//Destroy thread.
+void cutDestroyThread(CUTThread thread);
+
+//Wait for multiple threads.
+void cutWaitForThreads(const CUTThread *threads, int num);
+
+#ifdef __cplusplus
+} //extern "C"
+#endif
+
+#endif //MULTITHREADING_H

Common/nvMath.h

@@ -0,0 +1,111 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+//
+// Template math library for common 3D functionality
+//
+// This code is in part deriver from glh, a cross platform glut helper library.
+// The copyright for glh follows this notice.
+//
+// Copyright (c) NVIDIA Corporation. All rights reserved.
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+    Copyright (c) 2000 Cass Everitt
+    Copyright (c) 2000 NVIDIA Corporation
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or
+    without modification, are permitted provided that the following
+    conditions are met:
+
+     * Redistributions of source code must retain the above
+       copyright notice, this list of conditions and the following
+       disclaimer.
+
+     * Redistributions in binary form must reproduce the above
+       copyright notice, this list of conditions and the following
+       disclaimer in the documentation and/or other materials
+       provided with the distribution.
+
+     * The names of contributors to this software may not be used
+       to endorse or promote products derived from this software
+       without specific prior written permission.
+
+       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+       ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+       LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+       FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+       REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+       INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+       BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+       LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+       CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+       LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+       ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+       POSSIBILITY OF SUCH DAMAGE.
+
+
+    Cass Everitt - cass@r3.nu
+*/
+
+#ifndef NV_MATH_H
+#define NV_MATH_H
+
+#include <math.h>
+
+#include <nvVector.h>
+#include <nvMatrix.h>
+#include <nvQuaternion.h>
+
+#define NV_PI   float(3.1415926535897932384626433832795)
+
+namespace nv
+{
+
+    typedef vec2<float> vec2f;
+    typedef vec3<float> vec3f;
+    typedef vec3<int> vec3i;
+    typedef vec3<unsigned int> vec3ui;
+    typedef vec4<float> vec4f;
+    typedef matrix4<float> matrix4f;
+    typedef quaternion<float> quaternionf;
+
+
+    inline void applyRotation(const quaternionf &r)
+    {
+        float angle;
+        vec3f axis;
+        r.get_value(axis, angle);
+        glRotatef(angle/3.1415926f * 180.0f, axis[0], axis[1], axis[2]);
+    }
+
+
+
+};
+
+#endif

Common/nvMatrix.h

@@ -0,0 +1,540 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+//
+// Template math library for common 3D functionality
+//
+// nvMatrix.h - template matrix code
+//
+// This code is in part deriver from glh, a cross platform glut helper library.
+// The copyright for glh follows this notice.
+//
+// Copyright (c) NVIDIA Corporation. All rights reserved.
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+    Copyright (c) 2000 Cass Everitt
+    Copyright (c) 2000 NVIDIA Corporation
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or
+    without modification, are permitted provided that the following
+    conditions are met:
+
+     * Redistributions of source code must retain the above
+       copyright notice, this list of conditions and the following
+       disclaimer.
+
+     * Redistributions in binary form must reproduce the above
+       copyright notice, this list of conditions and the following
+       disclaimer in the documentation and/or other materials
+       provided with the distribution.
+
+     * The names of contributors to this software may not be used
+       to endorse or promote products derived from this software
+       without specific prior written permission.
+
+       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+       ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+       LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+       FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+       REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+       INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+       BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+       LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+       CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+       LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+       ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+       POSSIBILITY OF SUCH DAMAGE.
+
+
+    Cass Everitt - cass@r3.nu
+*/
+
+#ifndef NV_MATRIX_H
+#define NV_MATRIX_H
+
+namespace nv
+{
+
+    template <class T> class vec2;
+    template <class T> class vec3;
+    template <class T> class vec4;
+
+    ////////////////////////////////////////////////////////////////////////////////
+    //
+    //  Matrix
+    //
+    ////////////////////////////////////////////////////////////////////////////////
+    template<class T>
+    class matrix4
+    {
+
+        public:
+
+            matrix4()
+            {
+                make_identity();
+            }
+
+            matrix4(T t)
+            {
+                set_value(t);
+            }
+
+            matrix4(const T *m)
+            {
+                set_value(m);
+            }
+
+            matrix4(T a00, T a01, T a02, T a03,
+                    T a10, T a11, T a12, T a13,
+                    T a20, T a21, T a22, T a23,
+                    T a30, T a31, T a32, T a33) :
+                _11(a00), _12(a01), _13(a02), _14(a03),
+                _21(a10), _22(a11), _23(a12), _24(a13),
+                _31(a20), _32(a21), _33(a22), _34(a23),
+                _41(a30), _42(a31), _43(a32), _44(a33)
+            {}
+
+
+            void get_value(T *mp) const
+            {
+                int c = 0;
+
+                for (int j=0; j < 4; j++)
+                    for (int i=0; i < 4; i++)
+                    {
+                        mp[c++] = element(i,j);
+                    }
+            }
+
+            const T *get_value() const
+            {
+                return _array;
+            }
+
+            void set_value(T *mp)
+            {
+                int c = 0;
+
+                for (int j=0; j < 4; j++)
+                    for (int i=0; i < 4; i++)
+                    {
+                        element(i,j) = mp[c++];
+                    }
+            }
+
+            void set_value(T r)
+            {
+                for (int i=0; i < 4; i++)
+                    for (int j=0; j < 4; j++)
+                    {
+                        element(i,j) = r;
+                    }
+            }
+
+            void make_identity()
+            {
+                element(0,0) = 1.0;
+                element(0,1) = 0.0;
+                element(0,2) = 0.0;
+                element(0,3) = 0.0;
+
+                element(1,0) = 0.0;
+                element(1,1) = 1.0;
+                element(1,2) = 0.0;
+                element(1,3) = 0.0;
+
+                element(2,0) = 0.0;
+                element(2,1) = 0.0;
+                element(2,2) = 1.0;
+                element(2,3) = 0.0;
+
+                element(3,0) = 0.0;
+                element(3,1) = 0.0;
+                element(3,2) = 0.0;
+                element(3,3) = 1.0;
+            }
+
+            // set a uniform scale
+            void set_scale(T s)
+            {
+                element(0,0) = s;
+                element(1,1) = s;
+                element(2,2) = s;
+            }
+
+            void set_scale(const vec3<T> &s)
+            {
+                for (int i = 0; i < 3; i++)
+                {
+                    element(i,i) = s[i];
+                }
+            }
+
+
+            void set_translate(const vec3<T> &t)
+            {
+                for (int i = 0; i < 3; i++)
+                {
+                    element(i,3) = t[i];
+                }
+            }
+
+            void set_row(int r, const vec4<T> &t)
+            {
+                for (int i = 0; i < 4; i++)
+                {
+                    element(r,i) = t[i];
+                }
+            }
+
+            void set_column(int c, const vec4<T> &t)
+            {
+                for (int i = 0; i < 4; i++)
+                {
+                    element(i,c) = t[i];
+                }
+            }
+
+            vec4<T> get_row(int r) const
+            {
+                vec4<T> v;
+
+                for (int i = 0; i < 4; i++)
+                {
+                    v[i] = element(r,i);
+                }
+
+                return v;
+            }
+
+            vec4<T> get_column(int c) const
+            {
+                vec4<T> v;
+
+                for (int i = 0; i < 4; i++)
+                {
+                    v[i] = element(i,c);
+                }
+
+                return v;
+            }
+
+            friend matrix4 inverse(const matrix4 &m)
+            {
+                matrix4 minv;
+
+                T r1[8], r2[8], r3[8], r4[8];
+                T *s[4], *tmprow;
+
+                s[0] = &r1[0];
+                s[1] = &r2[0];
+                s[2] = &r3[0];
+                s[3] = &r4[0];
+
+                register int i,j,p,jj;
+
+                for (i=0; i<4; i++)
+                {
+                    for (j=0; j<4; j++)
+                    {
+                        s[i][j] = m.element(i,j);
+
+                        if (i==j)
+                        {
+                            s[i][j+4] = 1.0;
+                        }
+                        else
+                        {
+                            s[i][j+4] = 0.0;
+                        }
+                    }
+                }
+
+                T scp[4];
+
+                for (i=0; i<4; i++)
+                {
+                    scp[i] = T(fabs(s[i][0]));
+
+                    for (j=1; j<4; j++)
+                        if (T(fabs(s[i][j])) > scp[i])
+                        {
+                            scp[i] = T(fabs(s[i][j]));
+                        }
+
+                    if (scp[i] == 0.0)
+                    {
+                        return minv;    // singular matrix!
+                    }
+                }
+
+                int pivot_to;
+                T scp_max;
+
+                for (i=0; i<4; i++)
+                {
+                    // select pivot row
+                    pivot_to = i;
+                    scp_max = T(fabs(s[i][i]/scp[i]));
+
+                    // find out which row should be on top
+                    for (p=i+1; p<4; p++)
+                        if (T(fabs(s[p][i]/scp[p])) > scp_max)
+                        {
+                            scp_max = T(fabs(s[p][i]/scp[p]));
+                            pivot_to = p;
+                        }
+
+                    // Pivot if necessary
+                    if (pivot_to != i)
+                    {
+                        tmprow = s[i];
+                        s[i] = s[pivot_to];
+                        s[pivot_to] = tmprow;
+                        T tmpscp;
+                        tmpscp = scp[i];
+                        scp[i] = scp[pivot_to];
+                        scp[pivot_to] = tmpscp;
+                    }
+
+                    T mji;
+
+                    // perform gaussian elimination
+                    for (j=i+1; j<4; j++)
+                    {
+                        mji = s[j][i]/s[i][i];
+                        s[j][i] = 0.0;
+
+                        for (jj=i+1; jj<8; jj++)
+                        {
+                            s[j][jj] -= mji*s[i][jj];
+                        }
+                    }
+                }
+
+                if (s[3][3] == 0.0)
+                {
+                    return minv;    // singular matrix!
+                }
+
+                //
+                // Now we have an upper triangular matrix.
+                //
+                //  x x x x | y y y y
+                //  0 x x x | y y y y
+                //  0 0 x x | y y y y
+                //  0 0 0 x | y y y y
+                //
+                //  we'll back substitute to get the inverse
+                //
+                //  1 0 0 0 | z z z z
+                //  0 1 0 0 | z z z z
+                //  0 0 1 0 | z z z z
+                //  0 0 0 1 | z z z z
+                //
+
+                T mij;
+
+                for (i=3; i>0; i--)
+                {
+                    for (j=i-1; j > -1; j--)
+                    {
+                        mij = s[j][i]/s[i][i];
+
+                        for (jj=j+1; jj<8; jj++)
+                        {
+                            s[j][jj] -= mij*s[i][jj];
+                        }
+                    }
+                }
+
+                for (i=0; i<4; i++)
+                    for (j=0; j<4; j++)
+                    {
+                        minv(i,j) = s[i][j+4] / s[i][i];
+                    }
+
+                return minv;
+            }
+
+
+            friend matrix4 transpose(const matrix4 &m)
+            {
+                matrix4 mtrans;
+
+                for (int i=0; i<4; i++)
+                    for (int j=0; j<4; j++)
+                    {
+                        mtrans(i,j) = m.element(j,i);
+                    }
+
+                return mtrans;
+            }
+
+            matrix4 &operator *= (const matrix4 &rhs)
+            {
+                matrix4 mt(*this);
+                set_value(T(0));
+
+                for (int i=0; i < 4; i++)
+                    for (int j=0; j < 4; j++)
+                        for (int c=0; c < 4; c++)
+                        {
+                            element(i,j) += mt(i,c) * rhs(c,j);
+                        }
+
+                return *this;
+            }
+
+            friend matrix4 operator * (const matrix4 &lhs, const matrix4 &rhs)
+            {
+                matrix4 r(T(0));
+
+                for (int i=0; i < 4; i++)
+                    for (int j=0; j < 4; j++)
+                        for (int c=0; c < 4; c++)
+                        {
+                            r.element(i,j) += lhs(i,c) * rhs(c,j);
+                        }
+
+                return r;
+            }
+
+            // dst = M * src
+            vec4<T> operator *(const vec4<T> &src) const
+            {
+                vec4<T> r;
+
+                for (int i = 0; i < 4; i++)
+                    r[i]  = (src[0] * element(i,0) + src[1] * element(i,1) +
+                             src[2] * element(i,2) + src[3] * element(i,3));
+
+                return r;
+            }
+
+            // dst = src * M
+            friend vec4<T> operator *(const vec4<T> &lhs, const matrix4 &rhs)
+            {
+                vec4<T> r;
+
+                for (int i = 0; i < 4; i++)
+                    r[i]  = (lhs[0] * rhs.element(0,i) + lhs[1] * rhs.element(1,i) +
+                             lhs[2] * rhs.element(2,i) + lhs[3] * rhs.element(3,i));
+
+                return r;
+            }
+
+            T &operator()(int row, int col)
+            {
+                return element(row,col);
+            }
+
+            const T &operator()(int row, int col) const
+            {
+                return element(row,col);
+            }
+
+            T &element(int row, int col)
+            {
+                return _array[row | (col<<2)];
+            }
+
+            const T &element(int row, int col) const
+            {
+                return _array[row | (col<<2)];
+            }
+
+            matrix4 &operator *= (const T &r)
+            {
+                for (int i = 0; i < 4; ++i)
+                {
+                    element(0,i) *= r;
+                    element(1,i) *= r;
+                    element(2,i) *= r;
+                    element(3,i) *= r;
+                }
+
+                return *this;
+            }
+
+            matrix4 &operator += (const matrix4 &mat)
+            {
+                for (int i = 0; i < 4; ++i)
+                {
+                    element(0,i) += mat.element(0,i);
+                    element(1,i) += mat.element(1,i);
+                    element(2,i) += mat.element(2,i);
+                    element(3,i) += mat.element(3,i);
+                }
+
+                return *this;
+            }
+
+
+            friend bool operator == (const matrix4 &lhs, const matrix4 &rhs)
+            {
+                bool r = true;
+
+                for (int i = 0; i < 16; i++)
+                {
+                    r &= lhs._array[i] == rhs._array[i];
+                }
+
+                return r;
+            }
+
+            friend bool operator != (const matrix4 &lhs, const matrix4 &rhs)
+            {
+                bool r = true;
+
+                for (int i = 0; i < 16; i++)
+                {
+                    r &= lhs._array[i] != rhs._array[i];
+                }
+
+                return r;
+            }
+
+            union
+            {
+                struct
+                {
+                    T _11, _12, _13, _14;   // standard names for components
+                    T _21, _22, _23, _24;   // standard names for components
+                    T _31, _32, _33, _34;   // standard names for components
+                    T _41, _42, _43, _44;   // standard names for components
+                };
+                T _array[16];     // array access
+            };
+    };
+
+};
+
+#endif

Common/nvQuaternion.h

@@ -0,0 +1,530 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+//
+// Template math library for common 3D functionality
+//
+// nvQuaterion.h - quaternion template and utility functions
+//
+// This code is in part deriver from glh, a cross platform glut helper library.
+// The copyright for glh follows this notice.
+//
+// Copyright (c) NVIDIA Corporation. All rights reserved.
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+    Copyright (c) 2000 Cass Everitt
+    Copyright (c) 2000 NVIDIA Corporation
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or
+    without modification, are permitted provided that the following
+    conditions are met:
+
+     * Redistributions of source code must retain the above
+       copyright notice, this list of conditions and the following
+       disclaimer.
+
+     * Redistributions in binary form must reproduce the above
+       copyright notice, this list of conditions and the following
+       disclaimer in the documentation and/or other materials
+       provided with the distribution.
+
+     * The names of contributors to this software may not be used
+       to endorse or promote products derived from this software
+       without specific prior written permission.
+
+       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+       ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+       LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+       FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+       REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+       INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+       BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+       LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+       CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+       LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+       ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+       POSSIBILITY OF SUCH DAMAGE.
+
+
+    Cass Everitt - cass@r3.nu
+*/
+#ifndef NV_QUATERNION_H
+#define NV_QUATERNION_H
+
+namespace nv
+{
+
+    template <class T> class vec2;
+    template <class T> class vec3;
+    template <class T> class vec4;
+
+    ////////////////////////////////////////////////////////////////////////////////
+    //
+    //  Quaternion
+    //
+    ////////////////////////////////////////////////////////////////////////////////
+
+    template< class T>
+    class quaternion
+    {
+        public:
+
+            quaternion() : x(0.0), y(0.0), z(0.0), w(0.0)
+            {
+            }
+
+            quaternion(const T v[4])
+            {
+                set_value(v);
+            }
+
+
+            quaternion(T q0, T q1, T q2, T q3)
+            {
+                set_value(q0, q1, q2, q3);
+            }
+
+
+            quaternion(const matrix4<T> &m)
+            {
+                set_value(m);
+            }
+
+
+            quaternion(const vec3<T> &axis, T radians)
+            {
+                set_value(axis, radians);
+            }
+
+
+            quaternion(const vec3<T> &rotateFrom, const vec3<T> &rotateTo)
+            {
+                set_value(rotateFrom, rotateTo);
+            }
+
+            quaternion(const vec3<T> &from_look, const vec3<T> &from_up,
+                       const vec3<T> &to_look, const vec3<T> &to_up)
+            {
+                set_value(from_look, from_up, to_look, to_up);
+            }
+
+            const T *get_value() const
+            {
+                return  &_array[0];
+            }
+
+            void get_value(T &q0, T &q1, T &q2, T &q3) const
+            {
+                q0 = _array[0];
+                q1 = _array[1];
+                q2 = _array[2];
+                q3 = _array[3];
+            }
+
+            quaternion &set_value(T q0, T q1, T q2, T q3)
+            {
+                _array[0] = q0;
+                _array[1] = q1;
+                _array[2] = q2;
+                _array[3] = q3;
+                return *this;
+            }
+
+            void get_value(vec3<T> &axis, T &radians) const
+            {
+                radians = T(acos(_array[3]) * T(2.0));
+
+                if (radians == T(0.0))
+                {
+                    axis = vec3<T>(0.0, 0.0, 1.0);
+                }
+                else
+                {
+                    axis[0] = _array[0];
+                    axis[1] = _array[1];
+                    axis[2] = _array[2];
+                    axis = normalize(axis);
+                }
+            }
+
+            void get_value(matrix4<T> &m) const
+            {
+                T s, xs, ys, zs, wx, wy, wz, xx, xy, xz, yy, yz, zz;
+
+                T norm = _array[0] * _array[0] + _array[1] * _array[1] + _array[2] * _array[2] + _array[3] * _array[3];
+
+                s = (norm == T(0.0)) ? T(0.0) : (T(2.0) / norm);
+
+                xs = _array[0] * s;
+                ys = _array[1] * s;
+                zs = _array[2] * s;
+
+                wx = _array[3] * xs;
+                wy = _array[3] * ys;
+                wz = _array[3] * zs;
+
+                xx = _array[0] * xs;
+                xy = _array[0] * ys;
+                xz = _array[0] * zs;
+
+                yy = _array[1] * ys;
+                yz = _array[1] * zs;
+                zz = _array[2] * zs;
+
+                m(0,0) = T(T(1.0) - (yy + zz));
+                m(1,0) = T(xy + wz);
+                m(2,0) = T(xz - wy);
+
+                m(0,1) = T(xy - wz);
+                m(1,1) = T(T(1.0) - (xx + zz));
+                m(2,1) = T(yz + wx);
+
+                m(0,2) = T(xz + wy);
+                m(1,2) = T(yz - wx);
+                m(2,2) = T(T(1.0) - (xx + yy));
+
+                m(3,0) = m(3,1) = m(3,2) = m(0,3) = m(1,3) = m(2,3) = T(0.0);
+                m(3,3) = T(1.0);
+            }
+
+            quaternion &set_value(const T *qp)
+            {
+                for (int i = 0; i < 4; i++)
+                {
+                    _array[i] = qp[i];
+                }
+
+                return *this;
+            }
+
+            quaternion &set_value(const matrix4<T> &m)
+            {
+                T tr, s;
+                int i, j, k;
+                const int nxt[3] = { 1, 2, 0 };
+
+                tr = m(0,0) + m(1,1) + m(2,2);
+
+                if (tr > T(0))
+                {
+                    s = T(sqrt(tr + m(3,3)));
+                    _array[3] = T(s * 0.5);
+                    s = T(0.5) / s;
+
+                    _array[0] = T((m(1,2) - m(2,1)) * s);
+                    _array[1] = T((m(2,0) - m(0,2)) * s);
+                    _array[2] = T((m(0,1) - m(1,0)) * s);
+                }
+                else
+                {
+                    i = 0;
+
+                    if (m(1,1) > m(0,0))
+                    {
+                        i = 1;
+                    }
+
+                    if (m(2,2) > m(i,i))
+                    {
+                        i = 2;
+                    }
+
+                    j = nxt[i];
+                    k = nxt[j];
+
+                    s = T(sqrt((m(i,j) - (m(j,j) + m(k,k))) + T(1.0)));
+
+                    _array[i] = T(s * 0.5);
+                    s = T(0.5 / s);
+
+                    _array[3] = T((m(j,k) - m(k,j)) * s);
+                    _array[j] = T((m(i,j) + m(j,i)) * s);
+                    _array[k] = T((m(i,k) + m(k,i)) * s);
+                }
+
+                return *this;
+            }
+
+            quaternion &set_value(const vec3<T> &axis, T theta)
+            {
+                T sqnorm = square_norm(axis);
+
+                if (sqnorm == T(0.0))
+                {
+                    // axis too small.
+                    x = y = z = T(0.0);
+                    w = T(1.0);
+                }
+                else
+                {
+                    theta *= T(0.5);
+                    T sin_theta = T(sin(theta));
+
+                    if (sqnorm != T(1))
+                    {
+                        sin_theta /= T(sqrt(sqnorm));
+                    }
+
+                    x = sin_theta * axis[0];
+                    y = sin_theta * axis[1];
+                    z = sin_theta * axis[2];
+                    w = T(cos(theta));
+                }
+
+                return *this;
+            }
+
+            quaternion &set_value(const vec3<T> &rotateFrom, const vec3<T> &rotateTo)
+            {
+                vec3<T> p1, p2;
+                T alpha;
+
+                p1 = normalize(rotateFrom);
+                p2 = normalize(rotateTo);
+
+                alpha = dot(p1, p2);
+
+                if (alpha == T(1.0))
+                {
+                    *this = quaternion();
+                    return *this;
+                }
+
+                // ensures that the anti-parallel case leads to a positive dot
+                if (alpha == T(-1.0))
+                {
+                    vec3<T> v;
+
+                    if (p1[0] != p1[1] || p1[0] != p1[2])
+                    {
+                        v = vec3<T>(p1[1], p1[2], p1[0]);
+                    }
+                    else
+                    {
+                        v = vec3<T>(-p1[0], p1[1], p1[2]);
+                    }
+
+                    v -= p1 * dot(p1, v);
+                    v = normalize(v);
+
+                    set_value(v, T(3.1415926));
+                    return *this;
+                }
+
+                p1 = normalize(cross(p1, p2));
+
+                set_value(p1,T(acos(alpha)));
+
+                return *this;
+            }
+
+            quaternion &set_value(const vec3<T> &from_look, const vec3<T> &from_up,
+                                  const vec3<T> &to_look, const vec3<T> &to_up)
+            {
+                quaternion r_look = quaternion(from_look, to_look);
+
+                vec3<T> rotated_from_up(from_up);
+                r_look.mult_vec(rotated_from_up);
+
+                quaternion r_twist = quaternion(rotated_from_up, to_up);
+
+                *this = r_twist;
+                *this *= r_look;
+                return *this;
+            }
+
+            quaternion &operator *= (const quaternion<T> &qr)
+            {
+                quaternion ql(*this);
+
+                w = ql.w * qr.w - ql.x * qr.x - ql.y * qr.y - ql.z * qr.z;
+                x = ql.w * qr.x + ql.x * qr.w + ql.y * qr.z - ql.z * qr.y;
+                y = ql.w * qr.y + ql.y * qr.w + ql.z * qr.x - ql.x * qr.z;
+                z = ql.w * qr.z + ql.z * qr.w + ql.x * qr.y - ql.y * qr.x;
+
+                return *this;
+            }
+
+            friend quaternion normalize(const quaternion<T> &q)
+            {
+                quaternion r(q);
+                T rnorm = T(1.0) / T(sqrt(q.w * q.w + q.x * q.x + q.y * q.y + q.z * q.z));
+
+                r.x *= rnorm;
+                r.y *= rnorm;
+                r.z *= rnorm;
+                r.w *= rnorm;
+            }
+
+            friend quaternion<T> conjugate(const quaternion<T> &q)
+            {
+                quaternion<T> r(q);
+                r._array[0] *= T(-1.0);
+                r._array[1] *= T(-1.0);
+                r._array[2] *= T(-1.0);
+                return r;
+            }
+
+            friend quaternion<T> inverse(const quaternion<T> &q)
+            {
+                return conjugate(q);
+            }
+
+            //
+            // Quaternion multiplication with cartesian vector
+            // v' = q*v*q(star)
+            //
+            void mult_vec(const vec3<T> &src, vec3<T> &dst) const
+            {
+                T v_coef = w * w - x * x - y * y - z * z;
+                T u_coef = T(2.0) * (src[0] * x + src[1] * y + src[2] * z);
+                T c_coef = T(2.0) * w;
+
+                dst.v[0] = v_coef * src.v[0] + u_coef * x + c_coef * (y * src.v[2] - z * src.v[1]);
+                dst.v[1] = v_coef * src.v[1] + u_coef * y + c_coef * (z * src.v[0] - x * src.v[2]);
+                dst.v[2] = v_coef * src.v[2] + u_coef * z + c_coef * (x * src.v[1] - y * src.v[0]);
+            }
+
+            void mult_vec(vec3<T> &src_and_dst) const
+            {
+                mult_vec(vec3<T>(src_and_dst), src_and_dst);
+            }
+
+            void scale_angle(T scaleFactor)
+            {
+                vec3<T> axis;
+                T radians;
+
+                get_value(axis, radians);
+                radians *= scaleFactor;
+                set_value(axis, radians);
+            }
+
+            friend quaternion<T> slerp(const quaternion<T> &p, const quaternion<T> &q, T alpha)
+            {
+                quaternion r;
+
+                T cos_omega = p.x * q.x + p.y * q.y + p.z * q.z + p.w * q.w;
+                // if B is on opposite hemisphere from A, use -B instead
+
+                int bflip;
+
+                if ((bflip = (cos_omega < T(0))))
+                {
+                    cos_omega = -cos_omega;
+                }
+
+                // complementary interpolation parameter
+                T beta = T(1) - alpha;
+
+                if (cos_omega >= T(1))
+                {
+                    return p;
+                }
+
+                T omega = T(acos(cos_omega));
+                T one_over_sin_omega = T(1.0) / T(sin(omega));
+
+                beta    = T(sin(omega*beta)  * one_over_sin_omega);
+                alpha   = T(sin(omega*alpha) * one_over_sin_omega);
+
+                if (bflip)
+                {
+                    alpha = -alpha;
+                }
+
+                r.x = beta * p._array[0]+ alpha * q._array[0];
+                r.y = beta * p._array[1]+ alpha * q._array[1];
+                r.z = beta * p._array[2]+ alpha * q._array[2];
+                r.w = beta * p._array[3]+ alpha * q._array[3];
+                return r;
+            }
+
+            T &operator [](int i)
+            {
+                return _array[i];
+            }
+
+            const T &operator [](int i) const
+            {
+                return _array[i];
+            }
+
+
+            friend bool operator == (const quaternion<T> &lhs, const quaternion<T> &rhs)
+            {
+                bool r = true;
+
+                for (int i = 0; i < 4; i++)
+                {
+                    r &= lhs._array[i] == rhs._array[i];
+                }
+
+                return r;
+            }
+
+            friend bool operator != (const quaternion<T> &lhs, const quaternion<T> &rhs)
+            {
+                bool r = true;
+
+                for (int i = 0; i < 4; i++)
+                {
+                    r &= lhs._array[i] == rhs._array[i];
+                }
+
+                return r;
+            }
+
+            friend quaternion<T> operator * (const quaternion<T> &lhs, const quaternion<T> &rhs)
+            {
+                quaternion r(lhs);
+                r *= rhs;
+                return r;
+            }
+
+
+            union
+            {
+                struct
+                {
+                    T x;
+                    T y;
+                    T z;
+                    T w;
+                };
+                T _array[4];
+            };
+
+    };
+
+
+
+};
+
+#endif

Common/nvShaderUtils.h

@@ -0,0 +1,260 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ *
+ * Utility functions for compiling shaders and programs
+ *
+ * Author: Evan Hart
+ * Copyright (c) NVIDIA Corporation. All rights reserved.
+ *
+ */
+
+
+#ifndef NV_SHADER_UTILS_H
+#define NV_SHADER_UTILS_H
+
+#include <stdio.h>
+#include <string.h>
+
+namespace nv {
+
+//
+//
+////////////////////////////////////////////////////////////
+inline GLuint CompileGLSLShader(GLenum target, const char *shader) {
+  GLuint object;
+
+  object = glCreateShader(target);
+
+  if (!object) {
+    return object;
+  }
+
+  glShaderSource(object, 1, &shader, NULL);
+
+  glCompileShader(object);
+
+  // check if shader compiled
+  GLint compiled = 0;
+  glGetShaderiv(object, GL_COMPILE_STATUS, &compiled);
+
+  if (!compiled) {
+#ifdef NV_REPORT_COMPILE_ERRORS
+    char temp[256] = "";
+    glGetShaderInfoLog(object, 256, NULL, temp);
+    fprintf(stderr, "Compile failed:\n%s\n", temp);
+#endif
+    glDeleteShader(object);
+    return 0;
+  }
+
+  return object;
+}
+
+//
+//
+////////////////////////////////////////////////////////////
+inline GLuint CompileGLSLShaderFromFile(GLenum target, const char *filename) {
+  FILE *shaderFile;
+  char *text;
+  long size;
+  size_t fsize = 0;
+
+  // read files as binary to prevent problems from newline translation
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+
+  if (fopen_s(&shaderFile, filename, "rb") != 0)
+#else
+  if ((shaderFile = fopen(filename, "rb")) == 0)
+#endif
+  {
+    return 0;
+  }
+
+  // Get the length of the file
+  fseek(shaderFile, 0, SEEK_END);
+  size = ftell(shaderFile);
+
+  // Read the file contents from the start, then close file and add a null
+  // terminator
+  fseek(shaderFile, 0, SEEK_SET);
+  text = new char[size + 1];
+  fsize = fread(text, size, 1, shaderFile);
+  fclose(shaderFile);
+
+  if (fsize == 0) {
+    printf("CompileGLSLShaderFromFile(), error... fsize = 0\n");
+  }
+
+  text[size] = '\0';
+
+  GLuint object = CompileGLSLShader(target, text);
+
+  delete[] text;
+
+  return object;
+}
+
+// Create a program composed of vertex and fragment shaders.
+inline GLuint LinkGLSLProgram(GLuint vertexShader, GLuint fragmentShader) {
+  GLuint program = glCreateProgram();
+  glAttachShader(program, vertexShader);
+  glAttachShader(program, fragmentShader);
+  glLinkProgram(program);
+
+#ifdef NV_REPORT_COMPILE_ERRORS
+  // Get error log.
+  GLint charsWritten, infoLogLength;
+  glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
+
+  char *infoLog = new char[infoLogLength];
+  glGetProgramInfoLog(program, infoLogLength, &charsWritten, infoLog);
+  printf(infoLog);
+  delete[] infoLog;
+#endif
+
+  // Test linker result.
+  GLint linkSucceed = GL_FALSE;
+  glGetProgramiv(program, GL_LINK_STATUS, &linkSucceed);
+
+  if (linkSucceed == GL_FALSE) {
+    glDeleteProgram(program);
+    return 0;
+  }
+
+  return program;
+}
+
+// Create a program composed of vertex, geometry and fragment shaders.
+inline GLuint LinkGLSLProgram(GLuint vertexShader, GLuint geometryShader,
+                              GLint inputType, GLint vertexOut,
+                              GLint outputType, GLuint fragmentShader) {
+  GLuint program = glCreateProgram();
+  glAttachShader(program, vertexShader);
+  glAttachShader(program, geometryShader);
+  glProgramParameteriEXT(program, GL_GEOMETRY_INPUT_TYPE_EXT, inputType);
+  glProgramParameteriEXT(program, GL_GEOMETRY_VERTICES_OUT_EXT, vertexOut);
+  glProgramParameteriEXT(program, GL_GEOMETRY_OUTPUT_TYPE_EXT, outputType);
+  glAttachShader(program, fragmentShader);
+  glLinkProgram(program);
+
+#ifdef NV_REPORT_COMPILE_ERRORS
+  // Get error log.
+  GLint charsWritten, infoLogLength;
+  glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
+
+  char *infoLog = new char[infoLogLength];
+  glGetProgramInfoLog(program, infoLogLength, &charsWritten, infoLog);
+  printf(infoLog);
+  delete[] infoLog;
+#endif
+
+  // Test linker result.
+  GLint linkSucceed = GL_FALSE;
+  glGetProgramiv(program, GL_LINK_STATUS, &linkSucceed);
+
+  if (linkSucceed == GL_FALSE) {
+    glDeleteProgram(program);
+    return 0;
+  }
+
+  return program;
+}
+
+//
+//
+////////////////////////////////////////////////////////////
+inline GLuint CompileASMShader(GLenum program_type, const char *code) {
+  GLuint program_id;
+  glGenProgramsARB(1, &program_id);
+  glBindProgramARB(program_type, program_id);
+  glProgramStringARB(program_type, GL_PROGRAM_FORMAT_ASCII_ARB,
+                     (GLsizei)strlen(code), (GLubyte *)code);
+
+  GLint error_pos;
+  glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
+
+  if (error_pos != -1) {
+#ifdef NV_REPORT_COMPILE_ERRORS
+    const GLubyte *error_string;
+    error_string = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
+    fprintf(stderr, "Program error at position: %d\n%s\n", (int)error_pos,
+            error_string);
+#endif
+    return 0;
+  }
+
+  return program_id;
+}
+
+//
+//
+////////////////////////////////////////////////////////////
+inline GLuint CompileASMShaderFromFile(GLenum target, const char *filename) {
+  FILE *shaderFile;
+  char *text;
+  long size;
+  size_t fsize = 0;
+
+  // read files as binary to prevent problems from newline translation
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+
+  if (fopen_s(&shaderFile, filename, "rb") != 0)
+#else
+  if ((shaderFile = fopen(filename, "rb")) == 0)
+#endif
+  {
+    return 0;
+  }
+
+  // Get the length of the file
+  fseek(shaderFile, 0, SEEK_END);
+  size = ftell(shaderFile);
+
+  // Read the file contents from the start, then close file and add a null
+  // terminator
+  fseek(shaderFile, 0, SEEK_SET);
+  text = new char[size + 1];
+  fsize = fread(text, size, 1, shaderFile);
+  fclose(shaderFile);
+
+  if (fsize == 0) {
+    printf("CompileGLSLShaderFromFile(), error... fsize = 0\n");
+  }
+
+  text[size] = '\0';
+
+  GLuint program_id = CompileASMShader(target, text);
+
+  delete[] text;
+
+  return program_id;
+}
+
+}  // namespace nv
+#endif

Common/nvrtc_helper.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -47,8 +47,13 @@
     }                                                           \
   } while (0)
 
-void compileFileToPTX(char *filename, int argc, char **argv, char **ptxResult,
-                      size_t *ptxResultSize, int requiresCGheaders) {
+void compileFileToCUBIN(char *filename, int argc, char **argv, char **cubinResult,
+                      size_t *cubinResultSize, int requiresCGheaders) {
+  if (!filename) {
+    std::cerr << "\nerror: filename is empty for compileFileToCUBIN()!\n";
+    exit(1);
+  }
+
   std::ifstream inputFile(filename,
                           std::ios::in | std::ios::binary | std::ios::ate);
 
@@ -68,7 +73,37 @@ void compileFileToPTX(char *filename, int argc, char **argv, char **ptxResult,
 
   int numCompileOptions = 0;
 
-  char *compileParams[1];
+  char *compileParams[2];
+
+  int major = 0, minor = 0;
+  char deviceName[256];
+
+  // Picks the best CUDA device available
+  CUdevice cuDevice = findCudaDeviceDRV(argc, (const char **)argv);
+
+  // get compute capabilities and the devicename
+  checkCudaErrors(cuDeviceGetAttribute(
+      &major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, cuDevice));
+  checkCudaErrors(cuDeviceGetAttribute(
+      &minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, cuDevice));
+  
+  {
+  // Compile cubin for the GPU arch on which are going to run cuda kernel.
+  std::string compileOptions;
+  compileOptions = "--gpu-architecture=sm_";
+
+  compileParams[numCompileOptions] = reinterpret_cast<char *>(
+                  malloc(sizeof(char) * (compileOptions.length() + 10)));
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+  sprintf_s(compileParams[numCompileOptions], sizeof(char) * (compileOptions.length() + 10),
+            "%s%d%d", compileOptions.c_str(), major, minor);
+#else
+  snprintf(compileParams[numCompileOptions], compileOptions.size() + 10, "%s%d%d",
+           compileOptions.c_str(), major, minor);
+#endif
+  }
+
+  numCompileOptions++;
 
   if (requiresCGheaders) {
     std::string compileOptions;
@@ -81,7 +116,12 @@ void compileFileToPTX(char *filename, int argc, char **argv, char **ptxResult,
 
     compileOptions = "--include-path=";
 
-    std::string path = sdkFindFilePath(HeaderNames, argv[0]);
+    char *strPath = sdkFindFilePath(HeaderNames, argv[0]);
+    if (!strPath) {
+      std::cerr << "\nerror: header file " << HeaderNames << " not found!\n";
+      exit(1);
+    }
+    std::string path = strPath;
     if (!path.empty()) {
       std::size_t found = path.find(HeaderNames);
       path.erase(found);
@@ -90,15 +130,16 @@ void compileFileToPTX(char *filename, int argc, char **argv, char **ptxResult,
           "\nCooperativeGroups headers not found, please install it in %s "
           "sample directory..\n Exiting..\n",
           argv[0]);
+      exit(1);
     }
     compileOptions += path.c_str();
-    compileParams[0] = reinterpret_cast<char *>(
+    compileParams[numCompileOptions] = reinterpret_cast<char *>(
         malloc(sizeof(char) * (compileOptions.length() + 1)));
 #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
-    sprintf_s(compileParams[0], sizeof(char) * (compileOptions.length() + 1),
+    sprintf_s(compileParams[numCompileOptions], sizeof(char) * (compileOptions.length() + 1),
               "%s", compileOptions.c_str());
 #else
-    snprintf(compileParams[0], compileOptions.size(), "%s",
+    snprintf(compileParams[numCompileOptions], compileOptions.size(), "%s",
              compileOptions.c_str());
 #endif
     numCompileOptions++;
@@ -128,19 +169,20 @@ void compileFileToPTX(char *filename, int argc, char **argv, char **ptxResult,
   free(log);
 
   NVRTC_SAFE_CALL("nvrtcCompileProgram", res);
-  // fetch PTX
-  size_t ptxSize;
-  NVRTC_SAFE_CALL("nvrtcGetPTXSize", nvrtcGetPTXSize(prog, &ptxSize));
-  char *ptx = reinterpret_cast<char *>(malloc(sizeof(char) * ptxSize));
-  NVRTC_SAFE_CALL("nvrtcGetPTX", nvrtcGetPTX(prog, ptx));
-  NVRTC_SAFE_CALL("nvrtcDestroyProgram", nvrtcDestroyProgram(&prog));
-  *ptxResult = ptx;
-  *ptxResultSize = ptxSize;
 
-  if (requiresCGheaders) free(compileParams[0]);
+  size_t codeSize;
+  NVRTC_SAFE_CALL("nvrtcGetCUBINSize", nvrtcGetCUBINSize(prog, &codeSize));
+  char *code = new char[codeSize];
+  NVRTC_SAFE_CALL("nvrtcGetCUBIN", nvrtcGetCUBIN(prog, code));
+  *cubinResult = code;
+  *cubinResultSize = codeSize;
+
+  for (int i = 0; i < numCompileOptions; i++) {
+    free(compileParams[i]);
+  }
 }
 
-CUmodule loadPTX(char *ptx, int argc, char **argv) {
+CUmodule loadCUBIN(char *cubin, int argc, char **argv) {
   CUmodule module;
   CUcontext context;
   int major = 0, minor = 0;
@@ -158,11 +200,10 @@ CUmodule loadPTX(char *ptx, int argc, char **argv) {
   printf("> GPU Device has SM %d.%d compute capability\n", major, minor);
 
   checkCudaErrors(cuInit(0));
-  checkCudaErrors(cuDeviceGet(&cuDevice, 0));
   checkCudaErrors(cuCtxCreate(&context, 0, cuDevice));
 
-  checkCudaErrors(cuModuleLoadDataEx(&module, ptx, 0, 0, 0));
-  free(ptx);
+  checkCudaErrors(cuModuleLoadData(&module, cubin));
+  free(cubin);
 
   return module;
 }

Common/param.h

@@ -0,0 +1,236 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ Simple parameter system
+ sgreen@nvidia.com 4/2001
+*/
+
+#ifndef PARAM_H
+#define PARAM_H
+
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+// base class for named parameter
+class ParamBase {
+ public:
+  ParamBase(const char *name) : m_name(name) {}
+  virtual ~ParamBase() {}
+
+  std::string &GetName() { return m_name; }
+
+  virtual float GetFloatValue() = 0;
+  virtual int GetIntValue() = 0;
+  virtual std::string GetValueString() = 0;
+
+  virtual void Reset() = 0;
+  virtual void Increment() = 0;
+  virtual void Decrement() = 0;
+
+  virtual float GetPercentage() = 0;
+  virtual void SetPercentage(float p) = 0;
+
+  virtual void Write(std::ostream &stream) = 0;
+  virtual void Read(std::istream &stream) = 0;
+
+  virtual bool IsList() = 0;
+
+ protected:
+  std::string m_name;
+};
+
+// derived class for single-valued parameter
+template <class T>
+class Param : public ParamBase {
+ public:
+  Param(const char *name, T value = 0, T min = 0, T max = 10000, T step = 1,
+        T *ptr = 0)
+      : ParamBase(name),
+        m_default(value),
+        m_min(min),
+        m_max(max),
+        m_step(step),
+        m_precision(3) {
+    if (ptr) {
+      m_ptr = ptr;
+    } else {
+      m_ptr = &m_value;
+    }
+
+    *m_ptr = value;
+  }
+  ~Param() {}
+
+  T GetValue() const { return *m_ptr; }
+  T SetValue(const T value) { *m_ptr = value; }
+
+  float GetFloatValue() { return (float)*m_ptr; }
+  int GetIntValue() { return (int)*m_ptr; }
+
+  std::string GetValueString() {
+    std::ostringstream ost;
+    ost << std::setprecision(m_precision) << std::fixed;
+    ost << *m_ptr;
+    return ost.str();
+  }
+
+  void SetPrecision(int x) { m_precision = x; }
+
+  float GetPercentage() { return (*m_ptr - m_min) / (float)(m_max - m_min); }
+
+  void SetPercentage(float p) { *m_ptr = (T)(m_min + p * (m_max - m_min)); }
+
+  void Reset() { *m_ptr = m_default; }
+
+  void Increment() {
+    *m_ptr += m_step;
+
+    if (*m_ptr > m_max) {
+      *m_ptr = m_max;
+    }
+  }
+
+  void Decrement() {
+    *m_ptr -= m_step;
+
+    if (*m_ptr < m_min) {
+      *m_ptr = m_min;
+    }
+  }
+
+  void Write(std::ostream &stream) {
+    stream << m_name << " " << *m_ptr << '\n';
+  }
+  void Read(std::istream &stream) { stream >> m_name >> *m_ptr; }
+
+  bool IsList() { return false; }
+
+ private:
+  T m_value;
+  T *m_ptr;  // pointer to value declared elsewhere
+  T m_default, m_min, m_max, m_step;
+  int m_precision;  // number of digits after decimal point in string output
+};
+
+const Param<int> dummy("error");
+
+// list of parameters
+class ParamList : public ParamBase {
+ public:
+  ParamList(const char *name = "") : ParamBase(name) { active = true; }
+  ~ParamList() {}
+
+  float GetFloatValue() { return 0.0f; }
+  int GetIntValue() { return 0; }
+
+  void AddParam(ParamBase *param) {
+    m_params.push_back(param);
+    m_map[param->GetName()] = param;
+    m_current = m_params.begin();
+  }
+
+  // look-up parameter based on name
+  ParamBase *GetParam(char *name) {
+    ParamBase *p = m_map[name];
+
+    if (p) {
+      return p;
+    } else {
+      return (ParamBase *)&dummy;
+    }
+  }
+
+  ParamBase *GetParam(int i) { return m_params[i]; }
+
+  ParamBase *GetCurrent() { return *m_current; }
+
+  int GetSize() { return (int)m_params.size(); }
+
+  std::string GetValueString() { return m_name; }
+
+  // functions to traverse list
+  void Reset() { m_current = m_params.begin(); }
+
+  void Increment() {
+    m_current++;
+
+    if (m_current == m_params.end()) {
+      m_current = m_params.begin();
+    }
+  }
+
+  void Decrement() {
+    if (m_current == m_params.begin()) {
+      m_current = m_params.end() - 1;
+    } else {
+      m_current--;
+    }
+  }
+
+  float GetPercentage() { return 0.0f; }
+  void SetPercentage(float /*p*/) {}
+
+  void Write(std::ostream &stream) {
+    stream << m_name << '\n';
+
+    for (std::vector<ParamBase *>::const_iterator p = m_params.begin();
+         p != m_params.end(); ++p) {
+      (*p)->Write(stream);
+    }
+  }
+
+  void Read(std::istream &stream) {
+    stream >> m_name;
+
+    for (std::vector<ParamBase *>::const_iterator p = m_params.begin();
+         p != m_params.end(); ++p) {
+      (*p)->Read(stream);
+    }
+  }
+
+  bool IsList() { return true; }
+
+  void ResetAll() {
+    for (std::vector<ParamBase *>::const_iterator p = m_params.begin();
+         p != m_params.end(); ++p) {
+      (*p)->Reset();
+    }
+  }
+
+ protected:
+  bool active;
+  std::vector<ParamBase *> m_params;
+  std::map<std::string, ParamBase *> m_map;
+  std::vector<ParamBase *>::const_iterator m_current;
+};
+
+#endif

Common/paramgl.h

@@ -0,0 +1,307 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+   ParamListGL
+   - class derived from ParamList to do simple OpenGL rendering of a parameter
+   list sgg 8/2001
+*/
+
+#ifndef PARAMGL_H
+#define PARAMGL_H
+
+#if defined(__APPLE__) || defined(MACOSX)
+#include <GLUT/glut.h>
+#else
+#include <GL/freeglut.h>
+#endif
+
+#include <param.h>
+#include <string.h>
+
+inline void beginWinCoords(void) {
+  glMatrixMode(GL_MODELVIEW);
+  glPushMatrix();
+  glLoadIdentity();
+  glTranslatef(0.0, (GLfloat)(glutGet(GLUT_WINDOW_HEIGHT) - 1.0), 0.0);
+  glScalef(1.0, -1.0, 1.0);
+
+  glMatrixMode(GL_PROJECTION);
+  glPushMatrix();
+  glLoadIdentity();
+  glOrtho(0, glutGet(GLUT_WINDOW_WIDTH), 0, glutGet(GLUT_WINDOW_HEIGHT), -1, 1);
+
+  glMatrixMode(GL_MODELVIEW);
+}
+
+inline void endWinCoords(void) {
+  glMatrixMode(GL_PROJECTION);
+  glPopMatrix();
+
+  glMatrixMode(GL_MODELVIEW);
+  glPopMatrix();
+}
+
+inline void glPrint(int x, int y, const char *s, void *font) {
+  glRasterPos2f((GLfloat)x, (GLfloat)y);
+  int len = (int)strlen(s);
+
+  for (int i = 0; i < len; i++) {
+    glutBitmapCharacter(font, s[i]);
+  }
+}
+
+inline void glPrintShadowed(int x, int y, const char *s, void *font,
+                            float *color) {
+  glColor3f(0.0, 0.0, 0.0);
+  glPrint(x - 1, y - 1, s, font);
+
+  glColor3fv((GLfloat *)color);
+  glPrint(x, y, s, font);
+}
+
+class ParamListGL : public ParamList {
+ public:
+  ParamListGL(const char *name = "")
+      : ParamList(name),
+        m_active(true),
+        m_text_color_selected(1.0, 1.0, 1.0),
+        m_text_color_unselected(0.75, 0.75, 0.75),
+        m_text_color_shadow(0.0, 0.0, 0.0),
+        m_bar_color_outer(0.25, 0.25, 0.25),
+        m_bar_color_inner(1.0, 1.0, 1.0) {
+    m_font = (void *)GLUT_BITMAP_9_BY_15;  // GLUT_BITMAP_8_BY_13;
+    m_font_h = 15;
+    m_bar_x = 260;
+    m_bar_w = 250;
+    m_bar_h = 10;
+    m_bar_offset = 5;
+    m_text_x = 5;
+    m_separation = 15;
+    m_value_x = 200;
+    m_start_x = 0;
+    m_start_y = 0;
+  }
+
+  void Render(int x, int y, bool shadow = false) {
+    beginWinCoords();
+
+    m_start_x = x;
+    m_start_y = y;
+
+    for (std::vector<ParamBase *>::const_iterator p = m_params.begin();
+         p != m_params.end(); ++p) {
+      if ((*p)->IsList()) {
+        ParamListGL *list = (ParamListGL *)(*p);
+        list->Render(x + 10, y);
+        y += m_separation * list->GetSize();
+      } else {
+        if (p == m_current) {
+          glColor3fv(&m_text_color_selected.r);
+        } else {
+          glColor3fv(&m_text_color_unselected.r);
+        }
+
+        if (shadow) {
+          glPrintShadowed(x + m_text_x, y + m_font_h, (*p)->GetName().c_str(),
+                          m_font,
+                          (p == m_current) ? &m_text_color_selected.r
+                                           : &m_text_color_unselected.r);
+          glPrintShadowed(x + m_value_x, y + m_font_h,
+                          (*p)->GetValueString().c_str(), m_font,
+                          (p == m_current) ? &m_text_color_selected.r
+                                           : &m_text_color_unselected.r);
+        } else {
+          glPrint(x + m_text_x, y + m_font_h, (*p)->GetName().c_str(), m_font);
+          glPrint(x + m_value_x, y + m_font_h, (*p)->GetValueString().c_str(),
+                  m_font);
+        }
+
+        glColor3fv((GLfloat *)&m_bar_color_outer.r);
+        glBegin(GL_LINE_LOOP);
+        glVertex2f((GLfloat)(x + m_bar_x), (GLfloat)(y + m_bar_offset));
+        glVertex2f((GLfloat)(x + m_bar_x + m_bar_w),
+                   (GLfloat)(y + m_bar_offset));
+        glVertex2f((GLfloat)(x + m_bar_x + m_bar_w),
+                   (GLfloat)(y + m_bar_offset + m_bar_h));
+        glVertex2f((GLfloat)(x + m_bar_x),
+                   (GLfloat)(y + m_bar_offset + m_bar_h));
+        glEnd();
+
+        glColor3fv((GLfloat *)&m_bar_color_inner.r);
+        glRectf(
+            (GLfloat)(x + m_bar_x), (GLfloat)(y + m_bar_offset + m_bar_h),
+            (GLfloat)(x + m_bar_x + ((m_bar_w - 1) * (*p)->GetPercentage())),
+            (GLfloat)(y + m_bar_offset + 1));
+
+        y += m_separation;
+      }
+    }
+
+    endWinCoords();
+  }
+
+  bool Mouse(int x, int y, int button = GLUT_LEFT_BUTTON,
+             int state = GLUT_DOWN) {
+    if ((y < m_start_y) ||
+        (y > (int)(m_start_y + (m_separation * m_params.size()) - 1))) {
+      m_active = false;
+      return false;
+    }
+
+    m_active = true;
+
+    int i = (y - m_start_y) / m_separation;
+
+    if ((button == GLUT_LEFT_BUTTON) && (state == GLUT_DOWN)) {
+#if defined(__GNUC__) && (__GNUC__ < 3)
+      m_current = &m_params[i];
+#else
+
+      // MJH: workaround since the version of vector::at used here is
+      // non-standard
+      for (m_current = m_params.begin(); m_current != m_params.end() && i > 0;
+           m_current++, i--)
+        ;
+
+        // m_current = (std::vector<ParamBase
+        // *>::const_iterator)&m_params.at(i);
+#endif
+
+      if ((x > m_bar_x) && (x < m_bar_x + m_bar_w)) {
+        Motion(x, y);
+      }
+    }
+
+    return true;
+  }
+
+  bool Motion(int x, int y) {
+    if ((y < m_start_y) ||
+        (y > m_start_y + (m_separation * (int)m_params.size()) - 1)) {
+      return false;
+    }
+
+    if (x < m_bar_x) {
+      (*m_current)->SetPercentage(0.0);
+      return true;
+    }
+
+    if (x > m_bar_x + m_bar_w) {
+      (*m_current)->SetPercentage(1.0);
+      return true;
+    }
+
+    (*m_current)->SetPercentage((x - m_bar_x) / (float)m_bar_w);
+    return true;
+  }
+
+  void Special(int key, int x, int y) {
+    if (!m_active) return;
+
+    switch (key) {
+      case GLUT_KEY_DOWN:
+        Increment();
+        break;
+
+      case GLUT_KEY_UP:
+        Decrement();
+        break;
+
+      case GLUT_KEY_RIGHT:
+        GetCurrent()->Increment();
+        break;
+
+      case GLUT_KEY_LEFT:
+        GetCurrent()->Decrement();
+        break;
+
+      case GLUT_KEY_HOME:
+        GetCurrent()->Reset();
+        break;
+
+      case GLUT_KEY_END:
+        GetCurrent()->SetPercentage(1.0);
+        break;
+    }
+
+    glutPostRedisplay();
+  }
+
+  void SetFont(void *font, int height) {
+    m_font = font;
+    m_font_h = height;
+  }
+
+  void SetSelectedColor(float r, float g, float b) {
+    m_text_color_selected = Color(r, g, b);
+  }
+  void SetUnSelectedColor(float r, float g, float b) {
+    m_text_color_unselected = Color(r, g, b);
+  }
+  void SetBarColorInner(float r, float g, float b) {
+    m_bar_color_inner = Color(r, g, b);
+  }
+  void SetBarColorOuter(float r, float g, float b) {
+    m_bar_color_outer = Color(r, g, b);
+  }
+
+  void SetActive(bool b) { m_active = b; }
+
+ private:
+  void *m_font;
+  int m_font_h;  // font height
+
+  int m_bar_x;       // bar start x position
+  int m_bar_w;       // bar width
+  int m_bar_h;       // bar height
+  int m_text_x;      // text start x position
+  int m_separation;  // bar separation in y
+  int m_value_x;     // value text x position
+  int m_bar_offset;  // bar offset in y
+
+  int m_start_x, m_start_y;
+
+  bool m_active;
+
+  struct Color {
+    Color(float _r, float _g, float _b) {
+      r = _r;
+      g = _g;
+      b = _b;
+    }
+    float r, g, b;
+  };
+
+  Color m_text_color_selected;
+  Color m_text_color_unselected;
+  Color m_text_color_shadow;
+  Color m_bar_color_outer;
+  Color m_bar_color_inner;
+};
+
+#endif

Common/rendercheck_d3d10.cpp

@@ -0,0 +1,128 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Utility funcs to wrap up saving a surface or the back buffer as a PPM file
+//  In addition, wraps up a threshold comparision of two PPMs.
+//
+//  These functions are designed to be used to implement an automated QA testing
+//  for SDK samples.
+//
+//  Author: Bryan Dudash
+//  Email: sdkfeedback@nvidia.com
+//
+// Copyright (c) NVIDIA Corporation. All rights reserved.
+////////////////////////////////////////////////////////////////////////////////
+
+#include <helper_functions.h>
+#include <rendercheck_d3d10.h>
+
+HRESULT CheckRenderD3D10::ActiveRenderTargetToPPM(ID3D10Device *pDevice,
+                                                  const char *zFileName) {
+  ID3D10RenderTargetView *pRTV = NULL;
+  pDevice->OMGetRenderTargets(1, &pRTV, NULL);
+
+  ID3D10Resource *pSourceResource = NULL;
+  pRTV->GetResource(&pSourceResource);
+
+  return ResourceToPPM(pDevice, pSourceResource, zFileName);
+}
+
+HRESULT CheckRenderD3D10::ResourceToPPM(ID3D10Device *pDevice,
+                                        ID3D10Resource *pResource,
+                                        const char *zFileName) {
+  D3D10_RESOURCE_DIMENSION rType;
+  pResource->GetType(&rType);
+
+  if (rType != D3D10_RESOURCE_DIMENSION_TEXTURE2D) {
+    printf("SurfaceToPPM: pResource is not a 2D texture! Aborting...\n");
+    return E_FAIL;
+  }
+
+  ID3D10Texture2D *pSourceTexture = (ID3D10Texture2D *)pResource;
+  ID3D10Texture2D *pTargetTexture = NULL;
+
+  D3D10_TEXTURE2D_DESC desc;
+  pSourceTexture->GetDesc(&desc);
+  desc.BindFlags = 0;
+  desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
+  desc.Usage = D3D10_USAGE_STAGING;
+
+  if (FAILED(pDevice->CreateTexture2D(&desc, NULL, &pTargetTexture))) {
+    printf(
+        "SurfaceToPPM: Unable to create target Texture resoruce! Aborting... "
+        "\n");
+    return E_FAIL;
+  }
+
+  pDevice->CopyResource(pTargetTexture, pSourceTexture);
+
+  D3D10_MAPPED_TEXTURE2D mappedTex2D;
+  pTargetTexture->Map(0, D3D10_MAP_READ, 0, &mappedTex2D);
+
+  // Need to convert from dx pitch to pitch=width
+  unsigned char *pPPMData = new unsigned char[desc.Width * desc.Height * 4];
+
+  for (unsigned int iHeight = 0; iHeight < desc.Height; iHeight++) {
+    memcpy(
+        &(pPPMData[iHeight * desc.Width * 4]),
+        (unsigned char *)(mappedTex2D.pData) + iHeight * mappedTex2D.RowPitch,
+        desc.Width * 4);
+  }
+
+  pTargetTexture->Unmap(0);
+
+  // Prepends the PPM header info and bumps byte data afterwards
+  sdkSavePPM4ub(zFileName, pPPMData, desc.Width, desc.Height);
+
+  delete[] pPPMData;
+  pTargetTexture->Release();
+
+  return S_OK;
+}
+
+bool CheckRenderD3D10::PPMvsPPM(const char *src_file, const char *ref_file,
+                                const char *exec_path, const float epsilon,
+                                const float threshold) {
+  char *ref_file_path = sdkFindFilePath(ref_file, exec_path);
+
+  if (ref_file_path == NULL) {
+    printf(
+        "CheckRenderD3D10::PPMvsPPM unable to find <%s> in <%s> Aborting "
+        "comparison!\n",
+        ref_file, exec_path);
+    printf(">>> Check info.xml and [project//data] folder <%s> <<<\n",
+           ref_file);
+    printf("Aborting comparison!\n");
+    printf("  FAILURE!\n");
+    return false;
+  }
+
+  return (sdkComparePPM(src_file, ref_file_path, epsilon, threshold, true) ==
+          true);
+}

Common/rendercheck_d3d10.h

@@ -0,0 +1,53 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#ifndef _RENDERCHECK_D3D10_H_
+#define _RENDERCHECK_D3D10_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <d3d10.h>
+
+class CheckRenderD3D10 {
+ public:
+  CheckRenderD3D10() {}
+
+  static HRESULT ActiveRenderTargetToPPM(ID3D10Device *pDevice,
+                                         const char *zFileName);
+  static HRESULT ResourceToPPM(ID3D10Device *pDevice, ID3D10Resource *pResource,
+                               const char *zFileName);
+
+  static bool PPMvsPPM(const char *src_file, const char *ref_file,
+                       const char *exec_path, const float epsilon,
+                       const float threshold = 0.0f);
+};
+
+#endif

Common/rendercheck_d3d11.cpp

@@ -0,0 +1,124 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Utility funcs to wrap up saving a surface or the back buffer as a PPM file
+//  In addition, wraps up a threshold comparision of two PPMs.
+//
+//  These functions are designed to be used to implement an automated QA testing for SDK samples.
+//
+//  Author: Bryan Dudash
+//  Email: sdkfeedback@nvidia.com
+//
+// Copyright (c) NVIDIA Corporation. All rights reserved.
+////////////////////////////////////////////////////////////////////////////////
+
+#include <helper_functions.h>
+#include <rendercheck_d3d11.h>
+
+HRESULT CheckRenderD3D11::ActiveRenderTargetToPPM(ID3D11Device *pDevice, const char *zFileName)
+{
+    ID3D11DeviceContext *pDeviceCtxt;
+    pDevice->GetImmediateContext(&pDeviceCtxt);
+    ID3D11RenderTargetView *pRTV = NULL;
+    pDeviceCtxt->OMGetRenderTargets(1,&pRTV,NULL);
+
+    ID3D11Resource *pSourceResource = NULL;
+    pRTV->GetResource(&pSourceResource);
+
+    return ResourceToPPM(pDevice,pSourceResource,zFileName);
+}
+
+HRESULT CheckRenderD3D11::ResourceToPPM(ID3D11Device *pDevice, ID3D11Resource *pResource, const char *zFileName)
+{
+    ID3D11DeviceContext *pDeviceCtxt;
+    pDevice->GetImmediateContext(&pDeviceCtxt);
+    D3D11_RESOURCE_DIMENSION rType;
+    pResource->GetType(&rType);
+
+    if (rType != D3D11_RESOURCE_DIMENSION_TEXTURE2D)
+    {
+        printf("SurfaceToPPM: pResource is not a 2D texture! Aborting...\n");
+        return E_FAIL;
+    }
+
+    ID3D11Texture2D *pSourceTexture = (ID3D11Texture2D *)pResource;
+    ID3D11Texture2D *pTargetTexture = NULL;
+
+    D3D11_TEXTURE2D_DESC desc;
+    pSourceTexture->GetDesc(&desc);
+    desc.BindFlags = 0;
+    desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+    desc.Usage = D3D11_USAGE_STAGING;
+
+    if (FAILED(pDevice->CreateTexture2D(&desc,NULL,&pTargetTexture)))
+    {
+        printf("SurfaceToPPM: Unable to create target Texture resoruce! Aborting... \n");
+        return E_FAIL;
+    }
+
+    pDeviceCtxt->CopyResource(pTargetTexture,pSourceTexture);
+
+    D3D11_MAPPED_SUBRESOURCE mappedTex2D;
+    pDeviceCtxt->Map(pTargetTexture, 0, D3D11_MAP_READ,0,&mappedTex2D);
+
+    // Need to convert from dx pitch to pitch=width
+    unsigned char *pPPMData = new unsigned char[desc.Width*desc.Height*4];
+
+    for (unsigned int iHeight = 0; iHeight<desc.Height; iHeight++)
+    {
+        memcpy(&(pPPMData[iHeight*desc.Width*4]),(unsigned char *)(mappedTex2D.pData)+iHeight*mappedTex2D.RowPitch,desc.Width*4);
+    }
+
+    pDeviceCtxt->Unmap(pTargetTexture, 0);
+
+    // Prepends the PPM header info and bumps byte data afterwards
+    sdkSavePPM4ub(zFileName, pPPMData, desc.Width, desc.Height);
+
+    delete [] pPPMData;
+    pTargetTexture->Release();
+
+    return S_OK;
+}
+
+bool CheckRenderD3D11::PPMvsPPM(const char *src_file, const char *ref_file, const char *exec_path,
+                                const float epsilon, const float threshold)
+{
+    char *ref_file_path = sdkFindFilePath(ref_file, exec_path);
+
+    if (ref_file_path == NULL)
+    {
+        printf("CheckRenderD3D11::PPMvsPPM unable to find <%s> in <%s> Aborting comparison!\n", ref_file, exec_path);
+        printf(">>> Check info.xml and [project//data] folder <%s> <<<\n", ref_file);
+        printf("Aborting comparison!\n");
+        printf("  FAILURE!\n");
+        return false;
+    }
+
+    return sdkComparePPM(src_file,ref_file_path,epsilon,threshold,true) == true;
+}

Common/rendercheck_d3d11.h

@@ -0,0 +1,52 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#ifndef _RENDERCHECK_D3D11_H_
+#define _RENDERCHECK_D3D11_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <d3d11.h>
+
+class CheckRenderD3D11
+{
+    public:
+
+        CheckRenderD3D11() {}
+
+        static HRESULT ActiveRenderTargetToPPM(ID3D11Device  *pDevice, const char *zFileName);
+        static HRESULT ResourceToPPM(ID3D11Device *pDevice, ID3D11Resource *pResource, const char *zFileName);
+
+        static bool PPMvsPPM(const char *src_file, const char *ref_file, const char *exec_path,
+                             const float epsilon, const float threshold = 0.0f);
+};
+
+#endif

Common/rendercheck_d3d9.cpp

@@ -0,0 +1,167 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Utility funcs to wrap up savings a surface or the back buffer as a PPM file
+//  In addition, wraps up a threshold comparision of two PPMs.
+//
+//  These functions are designed to be used to implement an automated QA testing
+//  for SDK samples.
+//
+//  Author: Bryan Dudash
+//  Email: sdkfeedback@nvidia.com
+//
+// Copyright (c) NVIDIA Corporation. All rights reserved.
+////////////////////////////////////////////////////////////////////////////////
+
+#include <helper_functions.h>
+#include <rendercheck_d3d9.h>
+
+// originally copied from checkrender_gl.cpp and slightly modified
+bool CheckRenderD3D9::PPMvsPPM(const char *src_file, const char *ref_file,
+                               const char *exec_path, const float epsilon,
+                               const float threshold) {
+  char *ref_file_path = sdkFindFilePath(ref_file, exec_path);
+
+  if (ref_file_path == NULL) {
+    printf(
+        "CheckRenderD3D9::PPMvsPPM unable to find <%s> in <%s> Aborting "
+        "comparison!\n",
+        ref_file, exec_path);
+    printf(">>> Check info.xml and [project//data] folder <%s> <<<\n",
+           ref_file);
+    printf("Aborting comparison!\n");
+    printf("  FAILURE!\n");
+    return false;
+  }
+
+  return (sdkComparePPM(src_file, ref_file_path, epsilon, threshold, true) ==
+          true);
+};
+
+HRESULT CheckRenderD3D9::BackbufferToPPM(IDirect3DDevice9 *pDevice,
+                                         const char *zFileName) {
+  IDirect3DSurface9 *pSurface = NULL;
+
+  if (FAILED(
+          pDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pSurface))) {
+    printf("Unable to get the back buffer.  Aborting...\n");
+    return E_FAIL;
+  }
+
+  // D3DXSaveSurfaceToFile("C:\\bing.dds",D3DXIFF_DDS,pSurface,NULL,NULL);
+
+  HRESULT hr = S_OK;
+  hr = SurfaceToPPM(pDevice, pSurface, zFileName);
+
+  pSurface->Release();
+
+  return hr;
+}
+
+HRESULT CheckRenderD3D9::SurfaceToPPM(IDirect3DDevice9 *pDevice,
+                                      IDirect3DSurface9 *pSurface,
+                                      const char *zFileName) {
+  D3DSURFACE_DESC pDesc;
+  pSurface->GetDesc(&pDesc);
+
+  // $$ For now only support common 8bit formats.  TODO: support for more
+  // complex formats via conversion?
+  if (!(pDesc.Format == D3DFMT_A8R8G8B8 || pDesc.Format == D3DFMT_X8R8G8B8)) {
+    return E_INVALIDARG;
+  }
+
+  IDirect3DTexture9 *pTargetTex = NULL;
+
+  if (FAILED(pDevice->CreateTexture(pDesc.Width, pDesc.Height, 1,
+                                    D3DUSAGE_DYNAMIC, pDesc.Format,
+                                    D3DPOOL_SYSTEMMEM, &pTargetTex, NULL))) {
+    printf("Unable to create texture for surface transfer! Aborting...\n");
+    return E_FAIL;
+  }
+
+  IDirect3DSurface9 *pTargetSurface = NULL;
+
+  if (FAILED(pTargetTex->GetSurfaceLevel(0, &pTargetSurface))) {
+    printf("Unable to get surface for surface transfer! Aborting...\n");
+    return E_FAIL;
+  }
+
+  // This is required because we cannot lock a D3DPOOL_DEAULT surface directly.
+  // So, we copy to our sysmem surface.
+  if (FAILED(pDevice->GetRenderTargetData(pSurface, pTargetSurface))) {
+    printf(
+        "Unable to GetRenderTargetData() for surface transfer! Aborting...\n");
+    return E_FAIL;
+  }
+
+  D3DLOCKED_RECT lockedRect;
+  HRESULT hr = pTargetSurface->LockRect(&lockedRect, NULL, 0);
+
+  // Need to convert from dx pitch to pitch=width
+  //
+  // $ PPM is BGR and not RGB it seems. Saved image looks "funny" in viewer(red
+  // and blue swapped), but since ref will be dumped using same method, this is
+  // ok.
+  //      however, if we want the saved image to be properly colored, then we
+  //      can swizzle the color bytes here.
+  unsigned char *pPPMData = new unsigned char[pDesc.Width * pDesc.Height * 4];
+
+  for (unsigned int iHeight = 0; iHeight < pDesc.Height; iHeight++) {
+#if 1  // swizzle to implment RGB to BGR conversion.
+
+    for (unsigned int iWidth = 0; iWidth < pDesc.Width; iWidth++) {
+      DWORD color = *(DWORD *)((unsigned char *)(lockedRect.pBits) +
+                               iHeight * lockedRect.Pitch + iWidth * 4);
+
+      // R<->B, [7:0] <-> [23:16], swizzle
+      color = ((color & 0xFF) << 16) | (color & 0xFF00) |
+              ((color & 0xFF0000) >> 16) | (color & 0xFF000000);
+
+      memcpy(&(pPPMData[(iHeight * pDesc.Width + iWidth) * 4]),
+             (unsigned char *)&color, 4);
+    }
+
+#else
+    memcpy(&(pPPMData[iHeight * pDesc.Width * 4]),
+           (unsigned char *)(lockedRect.pBits) + iHeight * lockedRect.Pitch,
+           pDesc.Width * 4);
+#endif
+  }
+
+  pTargetSurface->UnlockRect();
+
+  // Prepends the PPM header info and bumps byte data afterwards
+  sdkSavePPM4ub(zFileName, pPPMData, pDesc.Width, pDesc.Height);
+
+  delete[] pPPMData;
+  pTargetSurface->Release();
+  pTargetTex->Release();
+
+  return S_OK;
+}

Common/rendercheck_d3d9.h

@@ -0,0 +1,54 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#ifndef _RENDERCHECK_D3D9_H_
+#define _RENDERCHECK_D3D9_H_
+
+#include <assert.h>
+#include <d3d9.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+class CheckRenderD3D9 {
+ public:
+  CheckRenderD3D9() {}
+
+  static HRESULT BackbufferToPPM(IDirect3DDevice9 *pDevice,
+                                 const char *zFileName);
+  static HRESULT SurfaceToPPM(IDirect3DDevice9 *pDevice,
+                              IDirect3DSurface9 *pSurface,
+                              const char *zFileName);
+
+  static bool PPMvsPPM(const char *src_file, const char *ref_file,
+                       const char *exec_path, const float epsilon,
+                       const float threshold = 0.0f);
+};
+
+#endif

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions

Makefile

@@ -1,6 +1,6 @@
 ###############################################################################
 #
-# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
@@ -44,6 +44,9 @@ PROJECTS := $(filter-out $(FILTER_OUT),$(PROJECTS))
 %.ph_build :
 	+@$(MAKE) -C $(dir $*) $(MAKECMDGOALS)
 
+%.ph_test :
+	+@$(MAKE) -C $(dir $*) testrun
+
 %.ph_clean : 
 	+@$(MAKE) -C $(dir $*) clean $(USE_DEVICE)
 
@@ -55,6 +58,8 @@ all:  $(addsuffix .ph_build,$(PROJECTS))
 
 build: $(addsuffix .ph_build,$(PROJECTS))
 
+test : $(addsuffix .ph_test,$(PROJECTS))
+
 tidy:
 	@find * | egrep "#" | xargs rm -f
 	@find * | egrep "\~" | xargs rm -f

README.md

@@ -1,53 +1,21 @@
 # CUDA Samples
 
-Samples for CUDA Developers which demonstrates features in CUDA Toolkit. This version supports [CUDA Toolkit 10.1](https://developer.nvidia.com/cuda-downloads).
+Samples for CUDA Developers which demonstrates features in CUDA Toolkit. This version supports [CUDA Toolkit 12.5](https://developer.nvidia.com/cuda-downloads).
 
 ## Release Notes
 
 This section describes the release notes for the CUDA Samples on GitHub only.
 
-### CUDA 10.1
-*  Added `immaTensorCoreGemm`. Demonstrates integer GEMM computation using the Warp Matrix Multiply and Accumulate (WMMA) API for integers employing the Tensor Cores.
-*  Added `simpleIPC`. Demonstrates Inter Process Communication with one process per GPU for computation.
-*  Added `nvJPEG`. Demonstrates single and batched decoding of jpeg images using NVJPEG Library.
-*  Added `bandwidthTest`. It measures the memcopy bandwidth of the GPU and memcpy bandwidth across PCI-e.
-*  Added `reduction`. Demonstrates several important optimization strategies for Data-Parallel Algorithms like reduction.
-*  Update all the samples to support CUDA 10.1.
+### CUDA 12.5
 
-### CUDA 10.0
-*  Added `simpleCudaGraphs`. Demonstrates CUDA Graphs creation, instantiation and launch using Graphs APIs and Stream Capture APIs.
-*  Added `conjugateGradientCudaGraphs`. Demonstrates conjugate gradient solver on GPU using CUBLAS and CUSPARSE library calls captured and called using CUDA Graph APIs.
-*  Added `simpleVulkan`. Demonstrates Vulkan - CUDA Interop.
-*  Added `simpleD3D12`. Demonstrates DX12 - CUDA Interop.
-*  Added `UnifiedMemoryPerf`. Demonstrates performance comparision of various memory types involved in system.
-*  Added `p2pBandwidthLatencyTest`. Demonstrates Peer-To-Peer (P2P) data transfers between pairs of GPUs and computes latency and bandwidth.
-*  Added `systemWideAtomics`. Demonstrates system wide atomic instructions.
-*  Added `simpleCUBLASXT`. Demonstrates CUBLAS-XT library which performs GEMM operations over multiple GPUs.
-*  Added Windows OS support to `conjugateGradientMultiDeviceCG` sample.
-*  Removed support of Visual Studio 2010 from all samples.
-
-### CUDA 9.2
-
-This is the first release of CUDA Samples on GitHub:
-*  Added `vectorAdd_nvrtc`. Demonstrates runtime compilation library using NVRTC of a simple vectorAdd kernel.
-*  Added `warpAggregatedAtomicsCG`. Demonstrates warp aggregated atomics using Cooperative Groups.
-*  Added `deviceQuery`. Enumerates the properties of the CUDA devices present in the system.
-*  Added `matrixMul`. Demonstrates a matrix multiplication using shared memory through tiled approach.
-*  Added `matrixMulDrv`. Demonstrates a matrix multiplication using shared memory through tiled approach, uses CUDA Driver API.
-*  Added `cudaTensorCoreGemm`. Demonstrates a GEMM computation using the Warp Matrix Multiply and Accumulate (WMMA) API introduced in CUDA 9, as well as the new Tensor Cores introduced in the Volta chip family.
-*  Added `simpleVoteIntrinsics` which uses *_sync equivalent of the vote intrinsics _any, _all added since CUDA 9.0.
-*  Added `shfl_scan` which uses *_sync equivalent of the shfl intrinsics added since CUDA 9.0.
-*  Added `conjugateGradientMultiBlockCG`. Demonstrates a conjugate gradient solver on GPU using Multi Block Cooperative Groups.
-*  Added `conjugateGradientMultiDeviceCG`. Demonstrates a conjugate gradient solver on multiple GPUs using Multi Device Cooperative Groups, also uses unified memory prefetching and usage hints APIs.
-*  Added `simpleCUBLAS`. Demonstrates how perform GEMM operations using CUBLAS library.
-*  Added `simpleCUFFT`. Demonstrates how perform FFT operations using CUFFT library.
+### [older versions...](./CHANGELOG.md)
 
 ## Getting Started
 
 ### Prerequisites
 
-Download and install the [CUDA Toolkit 10.1](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
-For system requirements and installation instructions of cuda toolkit, please refer to the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/), the [Windows Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html), and the [Mac Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x/index.html).
+Download and install the [CUDA Toolkit 12.5](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+For system requirements and installation instructions of cuda toolkit, please refer to the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/), and the [Windows Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html).
 
 ### Getting the CUDA Samples
 
@@ -72,7 +40,6 @@ Each individual sample has its own set of solution files at:
 `<CUDA_SAMPLES_REPO>\Samples\<sample_dir>\`
 
 To build/examine all the samples at once, the complete solution files should be used. To build/examine a single sample, the individual sample solution files should be used.
-> **Note:** Some samples require that the Microsoft DirectX SDK (June 2010 or newer) be installed and that the VC++ directory paths are properly set up (**Tools > Options...**). Check [DirectX Dependencies](#directx) section for details."
 
 ### Linux
 The Linux samples are built using makefiles. To use the makefiles, change the current directory to the sample directory you wish to build, and run make:
@@ -99,58 +66,31 @@ The samples makefiles can take advantage of certain options:
     $ make HOST_COMPILER=g++
     ```
 
-### Mac
-The Mac samples are built using makefiles. To use the makefiles, change directory into the sample directory you wish to build, and run make:
-```
-$ cd <sample_dir>
-$ make
-```
-
-The samples makefiles can take advantage of certain options:
-
-*  **dbg=1** - build with debug symbols
-    ```
-    $ make dbg=1
-    ```
-
-*  **SMS="A B ..."** - override the SM architectures for which the sample will be built, where "A B ..." is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use SMS="50 60".
-    ```
-    $ make SMS="A B ..."
-    ```
-
-*  **HOST_COMPILER=<host_compiler>** - override the default clang host compiler. See the [Mac Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x/index.html#system-requirements) for a list of supported host compilers.
-    ```
-    $ make HOST_COMPILER=clang
-    ```
-
 ## Samples list
 
-### Samples by OS
+### [0. Introduction](./Samples/0_Introduction/README.md)
+Basic CUDA samples for beginners that illustrate key concepts with using CUDA and CUDA runtime APIs.
 
-#### Linux
-**[warpAggregatedAtomicsCG](./Samples/warpAggregatedAtomicsCG)** | **[conjugateGradientMultiBlockCG](./Samples/conjugateGradientMultiBlockCG)** | **[simpleIPC](./Samples/simpleIPC)** | **[shfl_scan](./Samples/shfl_scan)** |
----|---|---|---|
-**[conjugateGradientCudaGraphs](./Samples/conjugateGradientCudaGraphs)** | **[nvJPEG](./Samples/nvJPEG)** | **[simpleCudaGraphs](./Samples/simpleCudaGraphs)** | **[deviceQuery](./Samples/deviceQuery)** |
-**[simpleVoteIntrinsics](./Samples/simpleVoteIntrinsics)** | **[simpleCUBLASXT](./Samples/simpleCUBLASXT)** | **[UnifiedMemoryPerf](./Samples/UnifiedMemoryPerf)** | **[conjugateGradientMultiDeviceCG](./Samples/conjugateGradientMultiDeviceCG)** |
-**[matrixMulDrv](./Samples/matrixMulDrv)** | **[simpleCUFFT](./Samples/simpleCUFFT)** | **[reduction](./Samples/reduction)** | **[immaTensorCoreGemm](./Samples/immaTensorCoreGemm)** |
-**[bandwidthTest](./Samples/bandwidthTest)** | **[simpleCUBLAS](./Samples/simpleCUBLAS)** | **[cudaTensorCoreGemm](./Samples/cudaTensorCoreGemm)** | **[simpleVulkan](./Samples/simpleVulkan)** |
-**[vectorAdd_nvrtc](./Samples/vectorAdd_nvrtc)** | **[p2pBandwidthLatencyTest](./Samples/p2pBandwidthLatencyTest)** | **[matrixMul](./Samples/matrixMul)** | **[systemWideAtomics](./Samples/systemWideAtomics)** |
+### [1. Utilities](./Samples/1_Utilities/README.md)
+Utility samples that demonstrate how to query device capabilities and measure GPU/CPU bandwidth.
 
-#### Windows
-**[warpAggregatedAtomicsCG](./Samples/warpAggregatedAtomicsCG)** | **[conjugateGradientMultiBlockCG](./Samples/conjugateGradientMultiBlockCG)** | **[simpleIPC](./Samples/simpleIPC)** | **[shfl_scan](./Samples/shfl_scan)** |
----|---|---|---|
-**[conjugateGradientCudaGraphs](./Samples/conjugateGradientCudaGraphs)** | **[simpleD3D12](./Samples/simpleD3D12)** | **[simpleCudaGraphs](./Samples/simpleCudaGraphs)** | **[deviceQuery](./Samples/deviceQuery)** |
-**[simpleVoteIntrinsics](./Samples/simpleVoteIntrinsics)** | **[simpleCUBLASXT](./Samples/simpleCUBLASXT)** | **[UnifiedMemoryPerf](./Samples/UnifiedMemoryPerf)** | **[conjugateGradientMultiDeviceCG](./Samples/conjugateGradientMultiDeviceCG)** |
-**[matrixMulDrv](./Samples/matrixMulDrv)** | **[simpleCUFFT](./Samples/simpleCUFFT)** | **[reduction](./Samples/reduction)** | **[immaTensorCoreGemm](./Samples/immaTensorCoreGemm)** |
-**[bandwidthTest](./Samples/bandwidthTest)** | **[simpleCUBLAS](./Samples/simpleCUBLAS)** | **[cudaTensorCoreGemm](./Samples/cudaTensorCoreGemm)** | **[simpleVulkan](./Samples/simpleVulkan)** |
-**[vectorAdd_nvrtc](./Samples/vectorAdd_nvrtc)** | **[p2pBandwidthLatencyTest](./Samples/p2pBandwidthLatencyTest)** | **[matrixMul](./Samples/matrixMul)** |
+### [2. Concepts and Techniques](./Samples/2_Concepts_and_Techniques/README.md)
+Samples that demonstrate CUDA related concepts and common problem solving techniques.
 
-#### Mac OSX
-**[warpAggregatedAtomicsCG](./Samples/warpAggregatedAtomicsCG)** | **[shfl_scan](./Samples/shfl_scan)** | **[conjugateGradientCudaGraphs](./Samples/conjugateGradientCudaGraphs)** | **[simpleCudaGraphs](./Samples/simpleCudaGraphs)** |
----|---|---|---|
-**[deviceQuery](./Samples/deviceQuery)** | **[simpleVoteIntrinsics](./Samples/simpleVoteIntrinsics)** | **[simpleCUBLASXT](./Samples/simpleCUBLASXT)** | **[UnifiedMemoryPerf](./Samples/UnifiedMemoryPerf)** |
-**[matrixMulDrv](./Samples/matrixMulDrv)** | **[simpleCUFFT](./Samples/simpleCUFFT)** | **[reduction](./Samples/reduction)** | **[bandwidthTest](./Samples/bandwidthTest)** |
-**[simpleCUBLAS](./Samples/simpleCUBLAS)** | **[vectorAdd_nvrtc](./Samples/vectorAdd_nvrtc)** | **[p2pBandwidthLatencyTest](./Samples/p2pBandwidthLatencyTest)** | **[matrixMul](./Samples/matrixMul)** |
+### [3. CUDA Features](./Samples/3_CUDA_Features/README.md)
+Samples that demonstrate CUDA Features (Cooperative Groups, CUDA Dynamic Parallelism, CUDA Graphs etc).
+
+### [4. CUDA Libraries](./Samples/4_CUDA_Libraries/README.md)
+Samples that demonstrate how to use CUDA platform libraries (NPP, NVJPEG, NVGRAPH cuBLAS, cuFFT, cuSPARSE, cuSOLVER and cuRAND).
+
+### [5. Domain Specific](./Samples/5_Domain_Specific/README.md)
+Samples that are specific to domain (Graphics, Finance, Image Processing).
+
+### [6. Performance](./Samples/6_Performance/README.md)
+Samples that demonstrate performance optimization.
+
+### [7. libNVVM](./Samples/7_libNVVM/README.md)
+Samples that demonstrate the use of libNVVVM and NVVM IR.
 
 ## Dependencies
 
@@ -166,7 +106,9 @@ These third-party dependencies are required by some CUDA samples. If available,
 
 #### FreeImage
 
-FreeImage is an open source imaging library. FreeImage can usually be installed on Linux using your distribution's package manager system. FreeImage can also be downloaded from the [FreeImage website](http://freeimage.sourceforge.net/). FreeImage is also redistributed with the CUDA Samples.
+FreeImage is an open source imaging library. FreeImage can usually be installed on Linux using your distribution's package manager system. FreeImage can also be downloaded from the FreeImage website.
+
+To set up FreeImage on a Windows system, extract the FreeImage DLL distribution into the folder `../../../Common/FreeImage/Dist/x64` such that it contains the .h and .lib files. Copy the .dll file to root level `bin/win64/Debug` and `bin/win64/Release` folder.
 
 #### Message Passing Interface
 
@@ -178,7 +120,7 @@ Some samples can only be run on a 64-bit operating system.
 
 #### DirectX
 
-DirectX is a collection of APIs designed to allow development of multimedia applications on Microsoft platforms. For Microsoft platforms, NVIDIA's CUDA Driver supports DirectX. Several CUDA Samples for Windows demonstrates CUDA-DirectX Interoperability, for building such samples one needs to install [Direct X SDK (June 2010 or newer)](http://www.microsoft.com/en-us/download/details.aspx?id=6812) , this is required to be installed on Windows 7, Windows 10 and Windows Server 2008, Other Windows OSes do not need to explicitly install the DirectX SDK.
+DirectX is a collection of APIs designed to allow development of multimedia applications on Microsoft platforms. For Microsoft platforms, NVIDIA's CUDA Driver supports DirectX. Several CUDA Samples for Windows demonstrates CUDA-DirectX Interoperability, for building such samples one needs to install Microsoft Visual Studio 2012 or higher which provides Microsoft Windows SDK for Windows 8.
 
 #### DirectX12
 
@@ -220,6 +162,14 @@ EGLOutput is a set of EGL extensions which allow EGL to render directly to the d
 
 EGLSync is a set of EGL extensions which provides sync objects that are synchronization primitive, representing events whose completion can be tested or waited upon.
 
+#### NVSCI
+
+NvSci is a set of communication interface libraries out of which CUDA interops with NvSciBuf and NvSciSync. NvSciBuf allows applications to allocate and exchange buffers in memory. NvSciSync allows applications to manage synchronization objects which coordinate when sequences of operations begin and end.
+
+#### NvMedia
+
+NvMedia provides powerful processing of multimedia data for true hardware acceleration across NVIDIA Tegra devices. Applications leverage the NvMedia Application Programming Interface (API) to process the image and video data.
+
 ### CUDA Features
 
 These CUDA features are needed by some CUDA samples. They are provided by either the CUDA Toolkit or CUDA Driver. Some features may not be available on your system.
@@ -296,6 +246,10 @@ FP16 is a 16-bit floating-point format. One bit is used for the sign, five bits
 
 NVCC support of [C++11 features](https://en.wikipedia.org/wiki/C++11).
 
+#### CMake
+
+The libNVVM samples are built using [CMake](https://cmake.org/) 3.10 or later.
+
 ## Contributors Guide
 
 We welcome your input on issues and suggestions for samples. At this time we are not accepting contributions from the public, check back here as we evolve our contribution model.
@@ -309,5 +263,8 @@ Answers to frequently asked questions about CUDA can be found at http://develope
 ## References
 
 *   [CUDA Programming Guide](http://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html)
-*   [Accelerated Computing Blog](https://devblogs.nvidia.com/category/accelerated-computing/)
+*   [Accelerated Computing Blog](https://developer.nvidia.com/blog/?tags=accelerated-computing)
 
+## Attributions
+
+*   Teapot image is obtained from [Wikimedia](https://en.wikipedia.org/wiki/File:Original_Utah_Teapot.jpg) and is licensed under the Creative Commons [Attribution-Share Alike 2.0](https://creativecommons.org/licenses/by-sa/2.0/deed.en) Generic license. The image is modified for samples use cases.

Samples/0_Introduction/README.md

@@ -0,0 +1,162 @@
+# 0. Introduction
+
+
+### [asyncAPI](./asyncAPI)
+This sample illustrates the usage of CUDA events for both GPU timing and overlapping CPU and GPU execution. Events are inserted into a stream of CUDA calls. Since CUDA stream calls are asynchronous, the CPU can perform computations while GPU is executing (including DMA memcopies between the host and device). CPU can query CUDA events to determine whether GPU has completed tasks.
+
+### [c++11_cuda](./c++11_cuda)
+This sample demonstrates C++11 feature support in CUDA. It scans a input text file and prints no. of occurrences of x, y, z, w characters. 
+
+### [clock](./clock)
+This example shows how to use the clock function to measure the performance of block of threads of a kernel accurately.
+
+### [clock_nvrtc](./clock_nvrtc)
+This example shows how to use the clock function using libNVRTC to measure the performance of block of threads of a kernel accurately.
+
+### [concurrentKernels](./concurrentKernels)
+This sample demonstrates the use of CUDA streams for concurrent execution of several kernels on GPU device. It also illustrates how to introduce dependencies between CUDA streams with the new cudaStreamWaitEvent function.
+
+### [cppIntegration](./cppIntegration)
+This example demonstrates how to integrate CUDA into an existing C++ application, i.e. the CUDA entry point on host side is only a function which is called from C++ code and only the file containing this function is compiled with nvcc. It also demonstrates that vector types can be used from cpp.
+
+### [cppOverload](./cppOverload)
+This sample demonstrates how to use C++ function overloading on the GPU.
+
+### [cudaOpenMP](./cudaOpenMP)
+This sample demonstrates how to use OpenMP API to write an application for multiple GPUs.
+
+### [fp16ScalarProduct](./fp16ScalarProduct)
+Calculates scalar product of two vectors of FP16 numbers.
+
+### [matrixMul](./matrixMul)
+This sample implements matrix multiplication and is exactly the same as Chapter 6 of the programming guide. It has been written for clarity of exposition to illustrate various CUDA programming principles, not with the goal of providing the most performant generic kernel for matrix multiplication.  To illustrate GPU performance for matrix multiply, this sample also shows how to use the new CUDA 4.0 interface for CUBLAS to demonstrate high-performance performance for matrix multiplication.
+
+### [matrixMul_nvrtc](./matrixMul_nvrtc)
+This sample implements matrix multiplication and is exactly the same as Chapter 6 of the programming guide. It has been written for clarity of exposition to illustrate various CUDA programming principles, not with the goal of providing the most performant generic kernel for matrix multiplication.  To illustrate GPU performance for matrix multiply, this sample also shows how to use the new CUDA 4.0 interface for CUBLAS to demonstrate high-performance performance for matrix multiplication.
+
+### [matrixMulDrv](./matrixMulDrv)
+This sample implements matrix multiplication and uses the new CUDA 4.0 kernel launch Driver API. It has been written for clarity of exposition to illustrate various CUDA programming principles, not with the goal of providing the most performant generic kernel for matrix multiplication. CUBLAS provides high-performance matrix multiplication.
+
+### [matrixMulDynlinkJIT](./matrixMulDynlinkJIT)
+This sample revisits matrix multiplication using the CUDA driver API. It demonstrates how to link to CUDA driver at runtime and how to use JIT (just-in-time) compilation from PTX code. It has been written for clarity of exposition to illustrate various CUDA programming principles, not with the goal of providing the most performant generic kernel for matrix multiplication. CUBLAS provides high-performance matrix multiplication.
+
+### [mergeSort](./mergeSort)
+This sample implements a merge sort (also known as Batcher's sort), algorithms belonging to the class of sorting networks. While generally subefficient on large sequences compared to algorithms with better asymptotic algorithmic complexity (i.e. merge sort or radix sort), may be the algorithms of choice for sorting batches of short- to mid-sized (key, value) array pairs. Refer to the excellent tutorial by H. W. Lang http://www.iti.fh-flensburg.de/lang/algorithmen/sortieren/networks/indexen.htm
+
+### [simpleAssert](./simpleAssert)
+This CUDA Runtime API sample is a very basic sample that implements how to use the assert function in the device code. Requires Compute Capability 2.0 .
+
+### [simpleAssert_nvrtc](./simpleAssert_nvrtc)
+This CUDA Runtime API sample is a very basic sample that implements how to use the assert function in the device code. Requires Compute Capability 2.0 .
+
+### [simpleAtomicIntrinsics](./simpleAtomicIntrinsics)
+A simple demonstration of global memory atomic instructions.
+
+### [simpleAtomicIntrinsics_nvrtc](./simpleAtomicIntrinsics_nvrtc)
+A simple demonstration of global memory atomic instructions.This sample makes use of NVRTC for Runtime Compilation.
+
+### [simpleAttributes](./simpleAttributes)
+This CUDA Runtime API sample is a very basic example that implements how to use the stream attributes that affect L2 locality. Performance improvement due to use of L2 access policy window can only be noticed on Compute capability 8.0 or higher.
+
+### [simpleAWBarrier](./simpleAWBarrier)
+A simple demonstration of arrive wait barriers.
+
+### [simpleCallback](./simpleCallback)
+This sample implements multi-threaded heterogeneous computing workloads with the new CPU callbacks for CUDA streams and events introduced with CUDA 5.0.
+
+### [simpleCooperativeGroups](./simpleCooperativeGroups)
+This sample is a simple code that illustrates basic usage of cooperative groups within the thread block.
+
+### [simpleCubemapTexture](./simpleCubemapTexture)
+Simple example that demonstrates how to use a new CUDA 4.1 feature to support cubemap Textures in CUDA C.
+
+### [simpleCUDA2GL](./simpleCUDA2GL)
+This sample shows how to copy CUDA image back to OpenGL using the most efficient methods.
+
+### [simpleDrvRuntime](./simpleDrvRuntime)
+A simple example which demonstrates how CUDA Driver and Runtime APIs can work together to load cuda fatbinary of vector add kernel and performing vector addition.
+
+### [simpleHyperQ](./simpleHyperQ)
+This sample demonstrates the use of CUDA streams for concurrent execution of several kernels on devices which provide HyperQ (SM 3.5).  Devices without HyperQ (SM 2.0 and SM 3.0) will run a maximum of two kernels concurrently.
+
+### [simpleIPC](./simpleIPC)
+This CUDA Runtime API sample is a very basic sample that demonstrates Inter Process Communication with one process per GPU for computation.  Requires Compute Capability 3.0 or higher and a Linux Operating System, or a Windows Operating System with TCC enabled GPUs
+
+### [simpleLayeredTexture](./simpleLayeredTexture)
+Simple example that demonstrates how to use a new CUDA 4.0 feature to support layered Textures in CUDA C.
+
+### [simpleMPI](./simpleMPI)
+Simple example demonstrating how to use MPI in combination with CUDA.
+
+### [simpleMultiCopy](./simpleMultiCopy)
+Supported in GPUs with Compute Capability 1.1, overlapping compute with one memcopy is possible from the host system.  For Quadro and Tesla GPUs with Compute Capability 2.0, a second overlapped copy operation in either direction at full speed is possible (PCI-e is symmetric).  This sample illustrates the usage of CUDA streams to achieve overlapping of kernel execution with data copies to and from the device.
+
+### [simpleMultiGPU](./simpleMultiGPU)
+This application demonstrates how to use the new CUDA 4.0 API for CUDA context management and multi-threaded access to run CUDA kernels on multiple-GPUs.
+
+### [simpleOccupancy](./simpleOccupancy)
+This sample demonstrates the basic usage of the CUDA occupancy calculator and occupancy-based launch configurator APIs by launching a kernel with the launch configurator, and measures the utilization difference against a manually configured launch.
+
+### [simpleP2P](./simpleP2P)
+This application demonstrates CUDA APIs that support Peer-To-Peer (P2P) copies, Peer-To-Peer (P2P) addressing, and Unified Virtual Memory Addressing (UVA) between multiple GPUs. In general, P2P is supported between two same GPUs with some exceptions, such as some Tesla and Quadro GPUs.
+
+### [simplePitchLinearTexture](./simplePitchLinearTexture)
+Use of Pitch Linear Textures
+
+### [simplePrintf](./simplePrintf)
+This basic CUDA Runtime API sample demonstrates how to use the printf function in the device code.
+
+### [simpleSeparateCompilation](./simpleSeparateCompilation)
+This sample demonstrates a CUDA 5.0 feature, the ability to create a GPU device static library and use it within another CUDA kernel.  This example demonstrates how to pass in a GPU device function (from the GPU device static library) as a function pointer to be called.  This sample requires devices with compute capability 2.0 or higher.
+
+### [simpleStreams](./simpleStreams)
+This sample uses CUDA streams to overlap kernel executions with memory copies between the host and a GPU device.  This sample uses a new CUDA 4.0 feature that supports pinning of generic host memory.  Requires Compute Capability 2.0 or higher.
+
+### [simpleSurfaceWrite](./simpleSurfaceWrite)
+Simple example that demonstrates the use of 2D surface references (Write-to-Texture)
+
+### [simpleTemplates](./simpleTemplates)
+This sample is a templatized version of the template project. It also shows how to correctly templatize dynamically allocated shared memory arrays.
+
+### [simpleTemplates_nvrtc](./simpleTemplates_nvrtc)
+This sample is a templatized version of the template project. It also shows how to correctly templatize dynamically allocated shared memory arrays.
+
+### [simpleTexture](./simpleTexture)
+Simple example that demonstrates use of Textures in CUDA.
+
+### [simpleTexture3D](./simpleTexture3D)
+Simple example that demonstrates use of 3D Textures in CUDA.
+
+### [simpleTextureDrv](./simpleTextureDrv)
+Simple example that demonstrates use of Textures in CUDA.  This sample uses the new CUDA 4.0 kernel launch Driver API.
+
+### [simpleVoteIntrinsics](./simpleVoteIntrinsics)
+Simple program which demonstrates how to use the Vote (__any_sync, __all_sync) intrinsic instruction in a CUDA kernel.
+
+### [simpleVoteIntrinsics_nvrtc](./simpleVoteIntrinsics_nvrtc)
+Simple program which demonstrates how to use the Vote (any, all) intrinsic instruction in a CUDA kernel with runtime compilation using NVRTC APIs. Requires Compute Capability 2.0 or higher.
+
+### [simpleZeroCopy](./simpleZeroCopy)
+This sample illustrates how to use Zero MemCopy, kernels can read and write directly to pinned system memory.
+
+### [systemWideAtomics](./systemWideAtomics)
+A simple demonstration of system wide atomic instructions.
+
+### [template](./template)
+A trivial template project that can be used as a starting point to create new CUDA projects.
+
+### [UnifiedMemoryStreams](./UnifiedMemoryStreams)
+This sample demonstrates the use of OpenMP and streams with Unified Memory on a single GPU.
+
+### [vectorAdd](./vectorAdd)
+This CUDA Runtime API sample is a very basic sample that implements element by element vector addition. It is the same as the sample illustrating Chapter 3 of the programming guide with some additions like error checking.
+
+### [vectorAdd_nvrtc](./vectorAdd_nvrtc)
+This CUDA Driver API sample uses NVRTC for runtime compilation of vector addition kernel. Vector addition kernel demonstrated is the same as the sample illustrating Chapter 3 of the programming guide.
+
+### [vectorAddDrv](./vectorAddDrv)
+This Vector Addition sample is a basic sample that is implemented element by element.  It is the same as the sample illustrating Chapter 3 of the programming guide with some additions like error checking.   This sample also uses the new CUDA 4.0 kernel launch Driver API.
+
+### [vectorAddMMAP](./vectorAddMMAP)
+This sample replaces the device allocation in the vectorAddDrv sample with cuMemMap-ed allocations.  This sample demonstrates that the cuMemMap api allows the user to specify the physical properties of their memory while retaining the contiguous nature of their access, thus not requiring a change in their program structure.
+

Samples/0_Introduction/UnifiedMemoryStreams/.vscode/c_cpp_properties.json

@@ -0,0 +1,18 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/../../../Common"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/local/cuda/bin/nvcc",
+            "cStandard": "gnu17",
+            "cppStandard": "gnu++14",
+            "intelliSenseMode": "linux-gcc-x64",
+            "configurationProvider": "ms-vscode.makefile-tools"
+        }
+    ],
+    "version": 4
+}

Samples/0_Introduction/UnifiedMemoryStreams/.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "nvidia.nsight-vscode-edition",
+        "ms-vscode.cpptools",
+        "ms-vscode.makefile-tools"
+    ]
+}

Samples/0_Introduction/UnifiedMemoryStreams/.vscode/launch.json

@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/UnifiedMemoryStreams"
+        }
+    ]
+}

Samples/0_Introduction/UnifiedMemoryStreams/.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "sample",
+            "type": "shell",
+            "command": "make dbg=1",
+            "problemMatcher": ["$nvcc"],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}

Samples/0_Introduction/UnifiedMemoryStreams/Makefile

@@ -0,0 +1,398 @@
+################################################################################
+# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#  * Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#  * Neither the name of NVIDIA CORPORATION nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+################################################################################
+#
+# Makefile project only supported on Mac OS X and Linux Platforms)
+#
+################################################################################
+
+# Location of the CUDA Toolkit
+CUDA_PATH ?= /usr/local/cuda
+
+##############################
+# start deprecated interface #
+##############################
+ifeq ($(x86_64),1)
+    $(info WARNING - x86_64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=x86_64 instead)
+    TARGET_ARCH ?= x86_64
+endif
+ifeq ($(ARMv7),1)
+    $(info WARNING - ARMv7 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=armv7l instead)
+    TARGET_ARCH ?= armv7l
+endif
+ifeq ($(aarch64),1)
+    $(info WARNING - aarch64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=aarch64 instead)
+    TARGET_ARCH ?= aarch64
+endif
+ifeq ($(ppc64le),1)
+    $(info WARNING - ppc64le variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=ppc64le instead)
+    TARGET_ARCH ?= ppc64le
+endif
+ifneq ($(GCC),)
+    $(info WARNING - GCC variable has been deprecated)
+    $(info WARNING - please use HOST_COMPILER=$(GCC) instead)
+    HOST_COMPILER ?= $(GCC)
+endif
+ifneq ($(abi),)
+    $(error ERROR - abi variable has been removed)
+endif
+############################
+# end deprecated interface #
+############################
+
+# architecture
+HOST_ARCH   := $(shell uname -m)
+TARGET_ARCH ?= $(HOST_ARCH)
+ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l))
+    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le))
+            TARGET_SIZE := 64
+        else ifneq (,$(filter $(TARGET_ARCH),armv7l))
+            TARGET_SIZE := 32
+        endif
+    else
+        TARGET_SIZE := $(shell getconf LONG_BIT)
+    endif
+else
+    $(error ERROR - unsupported value $(TARGET_ARCH) for TARGET_ARCH!)
+endif
+
+# sbsa and aarch64 systems look similar. Need to differentiate them at host level for now.
+ifeq ($(HOST_ARCH),aarch64)
+    ifeq ($(CUDA_PATH)/targets/sbsa-linux,$(shell ls -1d $(CUDA_PATH)/targets/sbsa-linux 2>/dev/null))
+        HOST_ARCH := sbsa
+        TARGET_ARCH := sbsa
+    endif
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 x86_64-sbsa x86_64-ppc64le))
+        $(error ERROR - cross compiling from $(HOST_ARCH) to $(TARGET_ARCH) is not supported!)
+    endif
+endif
+
+# When on native aarch64 system with userspace of 32-bit, change TARGET_ARCH to armv7l
+ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_SIZE),aarch64-aarch64-32)
+    TARGET_ARCH = armv7l
+endif
+
+# operating system
+HOST_OS   := $(shell uname -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+TARGET_OS ?= $(HOST_OS)
+ifeq (,$(filter $(TARGET_OS),linux darwin qnx android))
+    $(error ERROR - unsupported value $(TARGET_OS) for TARGET_OS!)
+endif
+
+# host compiler
+ifdef HOST_COMPILER
+ CUSTOM_HOST_COMPILER = 1
+endif
+
+ifeq ($(TARGET_OS),darwin)
+    ifeq ($(shell expr `xcodebuild -version | grep -i xcode | awk '{print $$2}' | cut -d'.' -f1` \>= 5),1)
+        HOST_COMPILER ?= clang++
+    endif
+else ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        ifeq ($(TARGET_OS),linux)
+            HOST_COMPILER ?= arm-linux-gnueabihf-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/arm-unknown-nto-qnx6.6.0eabi-g++
+        else ifeq ($(TARGET_OS),android)
+            HOST_COMPILER ?= arm-linux-androideabi-g++
+        endif
+    else ifeq ($(TARGET_ARCH),aarch64)
+        ifeq ($(TARGET_OS), linux)
+            HOST_COMPILER ?= aarch64-linux-gnu-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/q++
+        else ifeq ($(TARGET_OS), android)
+            HOST_COMPILER ?= aarch64-linux-android-clang++
+        endif
+    else ifeq ($(TARGET_ARCH),sbsa)
+        HOST_COMPILER ?= aarch64-linux-gnu-g++
+    else ifeq ($(TARGET_ARCH),ppc64le)
+        HOST_COMPILER ?= powerpc64le-linux-gnu-g++
+    endif
+endif
+HOST_COMPILER ?= g++
+NVCC          := $(CUDA_PATH)/bin/nvcc -ccbin $(HOST_COMPILER)
+
+# internal flags
+NVCCFLAGS   := -m${TARGET_SIZE}
+CCFLAGS     :=
+LDFLAGS     :=
+
+# build flags
+
+# Link flag for customized HOST_COMPILER with gcc realpath
+GCC_PATH := $(shell which gcc)
+ifeq ($(CUSTOM_HOST_COMPILER),1)
+    ifneq ($(filter /%,$(HOST_COMPILER)),)
+        ifneq ($(findstring gcc,$(HOST_COMPILER)),)
+            ifneq ($(GCC_PATH),$(HOST_COMPILER))
+                LDFLAGS += -lstdc++
+            endif
+        endif
+    endif
+endif
+
+ifeq ($(TARGET_OS),darwin)
+    LDFLAGS += -rpath $(CUDA_PATH)/lib
+    CCFLAGS += -arch $(HOST_ARCH)
+else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+    LDFLAGS += --dynamic-linker=/lib/ld-linux-armhf.so.3
+    CCFLAGS += -mfloat-abi=hard
+else ifeq ($(TARGET_OS),android)
+    LDFLAGS += -pie
+    CCFLAGS += -fpie -fpic -fexceptions
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib -L$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib/aarch64-linux-gnu -L$(TARGET_FS)/lib/aarch64-linux-gnu
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib -L$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/aarch64-linux-gnu -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+            LDFLAGS += --unresolved-symbols=ignore-in-shared-libs
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include/libdrm
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu -I$(TARGET_FS)/usr/include/aarch64-linux-gnu
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+        NVCCFLAGS += -D_QNX_SOURCE
+        NVCCFLAGS += --qpp-config 8.3.0,gcc_ntoaarch64le
+        CCFLAGS += -DWIN_INTERFACE_CUSTOM -I/usr/include/aarch64-qnx-gnu
+        LDFLAGS += -lsocket
+        LDFLAGS += -L/usr/lib/aarch64-qnx-gnu
+        CCFLAGS += "-Wl\,-rpath-link\,/usr/lib/aarch64-qnx-gnu"
+        ifdef TARGET_OVERRIDE
+            LDFLAGS += -lslog2
+        endif
+
+        ifneq ($(TARGET_FS),)
+            LDFLAGS += -L$(TARGET_FS)/usr/lib
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/lib"
+            LDFLAGS += -L$(TARGET_FS)/usr/libnvidia
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/libnvidia"
+            CCFLAGS += -I$(TARGET_FS)/../include
+        endif
+    endif
+endif
+
+ifdef TARGET_OVERRIDE # cuda toolkit targets override
+    NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
+endif
+
+# Install directory of different arch
+CUDA_INSTALL_TARGET_DIR :=
+ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-gnueabihf/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/sbsa-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
+else ifeq ($(TARGET_ARCH),ppc64le)
+    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
+endif
+
+# Debug build flags
+ifeq ($(dbg),1)
+      NVCCFLAGS += -g -G
+      BUILD_TYPE := debug
+else
+      BUILD_TYPE := release
+endif
+
+ALL_CCFLAGS :=
+ALL_CCFLAGS += $(NVCCFLAGS)
+ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
+
+UBUNTU = $(shell lsb_release -i -s 2>/dev/null | grep -i ubuntu)
+
+SAMPLE_ENABLED := 1
+
+# This sample is not supported on QNX
+ifeq ($(TARGET_OS),qnx)
+  $(info >>> WARNING - UnifiedMemoryStreams is not supported on QNX - waiving sample <<<)
+  SAMPLE_ENABLED := 0
+endif
+
+ALL_LDFLAGS :=
+ALL_LDFLAGS += $(ALL_CCFLAGS)
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
+
+# Common includes and paths for CUDA
+INCLUDES  := -I../../../Common
+LIBRARIES :=
+
+################################################################################
+
+# Attempt to compile a minimal OpenMP application. If a.out exists, OpenMP is properly set up.
+ifneq (,$(filter $(TARGET_OS),linux android))
+
+ifneq (,$(filter $(TARGET_OS), android))
+     LIBRARIES += -lomp
+else
+     LIBRARIES += -lgomp
+endif
+
+ALL_CCFLAGS += -Xcompiler -fopenmp
+$(shell echo "#include <omp.h>" > test.c ; echo "int main() { omp_get_num_threads(); return 0; }" >> test.c ; $(HOST_COMPILER) -fopenmp test.c)
+OPENMP ?= $(shell find a.out 2>/dev/null)
+
+ifeq ($(OPENMP),)
+      $(info -----------------------------------------------------------------------------------------------)
+      $(info WARNING - OpenMP is unable to compile)
+      $(info -----------------------------------------------------------------------------------------------)
+      $(info   This CUDA Sample cannot be built if the OpenMP compiler is not set up correctly.)
+      $(info   This will be a dry-run of the Makefile.)
+      $(info   For more information on how to set up your environment to build and run this )
+      $(info   sample, please refer the CUDA Samples documentation and release notes)
+      $(info -----------------------------------------------------------------------------------------------)
+      SAMPLE_ENABLED := 0
+endif
+
+$(shell rm a.out test.c 2>/dev/null)
+else
+LIBRARIES += -lpthread
+ALL_CCFLAGS += -DUSE_PTHREADS
+endif
+
+# Gencode arguments
+ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64 sbsa))
+SMS ?= 53 61 70 72 75 80 86 87 90
+else
+SMS ?= 50 52 60 61 70 75 80 86 89 90
+endif
+
+ifeq ($(SMS),)
+$(info >>> WARNING - no SM architectures have been specified - waiving sample <<<)
+SAMPLE_ENABLED := 0
+endif
+
+ifeq ($(GENCODE_FLAGS),)
+# Generate SASS code for each SM architecture listed in $(SMS)
+$(foreach sm,$(SMS),$(eval GENCODE_FLAGS += -gencode arch=compute_$(sm),code=sm_$(sm)))
+
+# Generate PTX code from the highest SM architecture in $(SMS) to guarantee forward-compatibility
+HIGHEST_SM := $(lastword $(sort $(SMS)))
+ifneq ($(HIGHEST_SM),)
+GENCODE_FLAGS += -gencode arch=compute_$(HIGHEST_SM),code=compute_$(HIGHEST_SM)
+endif
+endif
+
+ALL_CCFLAGS += --threads 0 --std=c++11
+
+LIBRARIES += -lcublas
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: UnifiedMemoryStreams
+
+check.deps:
+ifeq ($(SAMPLE_ENABLED),0)
+	@echo "Sample will be waived due to the above missing dependencies"
+else
+	@echo "Sample is ready - all dependencies have been met"
+endif
+
+UnifiedMemoryStreams.o:UnifiedMemoryStreams.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+UnifiedMemoryStreams: UnifiedMemoryStreams.o
+	$(EXEC) $(NVCC) $(ALL_LDFLAGS) $(GENCODE_FLAGS) -o $@ $+ $(LIBRARIES)
+	$(EXEC) mkdir -p ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+	$(EXEC) cp $@ ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+
+run: build
+	$(EXEC) ./UnifiedMemoryStreams
+
+testrun: build
+
+clean:
+	rm -f UnifiedMemoryStreams UnifiedMemoryStreams.o
+	rm -rf ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/UnifiedMemoryStreams
+
+clobber: clean

Samples/0_Introduction/UnifiedMemoryStreams/NsightEclipse.xml

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>UnifiedMemoryStreams</name>
+  <cuda_api_list>
+    <toolkit>cudaStreamDestroy</toolkit>
+    <toolkit>cudaFree</toolkit>
+    <toolkit>cudaMallocManaged</toolkit>
+    <toolkit>cudaStreamAttachMemAsync</toolkit>
+    <toolkit>cudaSetDevice</toolkit>
+    <toolkit>cudaDeviceSynchronize</toolkit>
+    <toolkit>cudaStreamSynchronize</toolkit>
+    <toolkit>cudaStreamCreate</toolkit>
+    <toolkit>cudaGetDeviceProperties</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[This sample demonstrates the use of OpenMP and streams with Unified Memory on a single GPU.]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="basic">CUDA Systems Integration</concept>
+    <concept level="basic">OpenMP</concept>
+    <concept level="basic">CUBLAS</concept>
+    <concept level="basic">Multithreading</concept>
+    <concept level="basic">Unified Memory</concept>
+    <concept level="basic">CUDA Streams and Events</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>CUDA</keyword>
+    <keyword>CUBLAS</keyword>
+    <keyword>OpenMP</keyword>
+    <keyword>cluster</keyword>
+    <keyword>multi-GPU Support</keyword>
+    <keyword>Unified Memory</keyword>
+    <keyword>UVM</keyword>
+    <keyword>openMP</keyword>
+    <keyword>Streams</keyword>
+    <keyword>pthreads</keyword>
+  </keywords>
+  <libraries>
+    <library>cublas</library>
+  </libraries>
+  <librarypaths>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>UnifiedMemoryStreams.cu</primary_file>
+  <required_dependencies>
+    <dependency>OpenMP</dependency>
+    <dependency>UVM</dependency>
+    <dependency>CUBLAS</dependency>
+  </required_dependencies>
+  <scopes>
+    <scope>1:CUDA Basic Topics</scope>
+    <scope>1:CUDA Systems Integration</scope>
+    <scope>1:Unified Memory</scope>
+  </scopes>
+  <supported_envs>
+    <env>
+      <arch>x86_64</arch>
+      <platform>linux</platform>
+    </env>
+    <env>
+      <arch>x86_64</arch>
+      <platform>macosx</platform>
+    </env>
+    <env>
+      <platform>windows7</platform>
+    </env>
+    <env>
+      <arch>arm</arch>
+    </env>
+    <env>
+      <arch>sbsa</arch>
+    </env>
+    <env>
+      <arch>ppc64le</arch>
+      <platform>linux</platform>
+    </env>
+  </supported_envs>
+  <supported_sm_architectures>
+    <from>3.5</from>
+  </supported_sm_architectures>
+  <title>Unified Memory Streams</title>
+  <type>exe</type>
+</entry>

Samples/0_Introduction/UnifiedMemoryStreams/README.md

@@ -0,0 +1,72 @@
+# UnifiedMemoryStreams - Unified Memory Streams
+
+## Description
+
+This sample demonstrates the use of OpenMP and streams with Unified Memory on a single GPU.
+
+## Key Concepts
+
+CUDA Systems Integration, OpenMP, CUBLAS, Multithreading, Unified Memory, CUDA Streams and Events
+
+## Supported SM Architectures
+
+## Supported OSes
+
+Linux, Windows
+
+## Supported CPU Architecture
+
+x86_64, ppc64le, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaStreamDestroy, cudaFree, cudaMallocManaged, cudaStreamAttachMemAsync, cudaSetDevice, cudaDeviceSynchronize, cudaStreamSynchronize, cudaStreamCreate, cudaGetDeviceProperties
+
+## Dependencies needed to build/run
+[OpenMP](../../../README.md#openmp), [UVM](../../../README.md#uvm), [CUBLAS](../../../README.md#cublas)
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit 12.5](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+Make sure the dependencies mentioned in [Dependencies]() section above are installed.
+
+## Build and Run
+
+### Windows
+The Windows samples are built using the Visual Studio IDE. Solution files (.sln) are provided for each supported version of Visual Studio, using the format:
+```
+*_vs<version>.sln - for Visual Studio <version>
+```
+Each individual sample has its own set of solution files in its directory:
+
+To build/examine all the samples at once, the complete solution files should be used. To build/examine a single sample, the individual sample solution files should be used.
+> **Note:** Some samples require that the Microsoft DirectX SDK (June 2010 or newer) be installed and that the VC++ directory paths are properly set up (**Tools > Options...**). Check DirectX Dependencies section for details."
+
+### Linux
+The Linux samples are built using makefiles. To use the makefiles, change the current directory to the sample directory you wish to build, and run make:
+```
+$ cd <sample_dir>
+$ make
+```
+The samples makefiles can take advantage of certain options:
+*  **TARGET_ARCH=<arch>** - cross-compile targeting a specific architecture. Allowed architectures are x86_64, ppc64le, armv7l.
+    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
+`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=ppc64le` <br/> `$ make TARGET_ARCH=armv7l` <br/>
+    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
+*   **dbg=1** - build with debug symbols
+    ```
+    $ make dbg=1
+    ```
+*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
+    ```
+    $ make SMS="50 60"
+    ```
+
+*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
+```
+    $ make HOST_COMPILER=g++
+```
+
+## References (for more details)
+

Samples/0_Introduction/UnifiedMemoryStreams/UnifiedMemoryStreams.cu

@@ -0,0 +1,341 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * This sample implements a simple task consumer using threads and streams
+ * with all data in Unified Memory, and tasks consumed by both host and device
+ */
+
+// system includes
+#include <cstdio>
+#include <ctime>
+#include <vector>
+#include <algorithm>
+#ifdef USE_PTHREADS
+#include <pthread.h>
+#else
+#include <omp.h>
+#endif
+#include <stdlib.h>
+
+// cuBLAS
+#include <cublas_v2.h>
+
+// utilities
+#include <helper_cuda.h>
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+// SRAND48 and DRAND48 don't exist on windows, but these are the equivalent
+// functions
+void srand48(long seed) { srand((unsigned int)seed); }
+double drand48() { return double(rand()) / RAND_MAX; }
+#endif
+
+const char *sSDKname = "UnifiedMemoryStreams";
+
+// simple task
+template <typename T>
+struct Task {
+  unsigned int size, id;
+  T *data;
+  T *result;
+  T *vector;
+
+  Task() : size(0), id(0), data(NULL), result(NULL), vector(NULL){};
+  Task(unsigned int s) : size(s), id(0), data(NULL), result(NULL) {
+    // allocate unified memory -- the operation performed in this example will
+    // be a DGEMV
+    checkCudaErrors(cudaMallocManaged(&data, sizeof(T) * size * size));
+    checkCudaErrors(cudaMallocManaged(&result, sizeof(T) * size));
+    checkCudaErrors(cudaMallocManaged(&vector, sizeof(T) * size));
+    checkCudaErrors(cudaDeviceSynchronize());
+  }
+
+  ~Task() {
+    // ensure all memory is deallocated
+    checkCudaErrors(cudaDeviceSynchronize());
+    checkCudaErrors(cudaFree(data));
+    checkCudaErrors(cudaFree(result));
+    checkCudaErrors(cudaFree(vector));
+  }
+
+  void allocate(const unsigned int s, const unsigned int unique_id) {
+    // allocate unified memory outside of constructor
+    id = unique_id;
+    size = s;
+    checkCudaErrors(cudaMallocManaged(&data, sizeof(T) * size * size));
+    checkCudaErrors(cudaMallocManaged(&result, sizeof(T) * size));
+    checkCudaErrors(cudaMallocManaged(&vector, sizeof(T) * size));
+    checkCudaErrors(cudaDeviceSynchronize());
+
+    // populate data with random elements
+    for (unsigned int i = 0; i < size * size; i++) {
+      data[i] = drand48();
+    }
+
+    for (unsigned int i = 0; i < size; i++) {
+      result[i] = 0.;
+      vector[i] = drand48();
+    }
+  }
+};
+
+#ifdef USE_PTHREADS
+struct threadData_t {
+  int tid;
+  Task<double> *TaskListPtr;
+  cudaStream_t *streams;
+  cublasHandle_t *handles;
+  int taskSize;
+};
+
+typedef struct threadData_t threadData;
+#endif
+
+// simple host dgemv: assume data is in row-major format and square
+template <typename T>
+void gemv(int m, int n, T alpha, T *A, T *x, T beta, T *result) {
+  // rows
+  for (int i = 0; i < n; i++) {
+    result[i] *= beta;
+
+    for (int j = 0; j < n; j++) {
+      result[i] += A[i * n + j] * x[j];
+    }
+  }
+}
+
+// execute a single task on either host or device depending on size
+#ifdef USE_PTHREADS
+void *execute(void *inpArgs) {
+  threadData *dataPtr = (threadData *)inpArgs;
+  cudaStream_t *stream = dataPtr->streams;
+  cublasHandle_t *handle = dataPtr->handles;
+  int tid = dataPtr->tid;
+
+  for (int i = 0; i < dataPtr->taskSize; i++) {
+    Task<double> &t = dataPtr->TaskListPtr[i];
+
+    if (t.size < 100) {
+      // perform on host
+      printf("Task [%d], thread [%d] executing on host (%d)\n", t.id, tid,
+             t.size);
+
+      // attach managed memory to a (dummy) stream to allow host access while
+      // the device is running
+      checkCudaErrors(
+          cudaStreamAttachMemAsync(stream[0], t.data, 0, cudaMemAttachHost));
+      checkCudaErrors(
+          cudaStreamAttachMemAsync(stream[0], t.vector, 0, cudaMemAttachHost));
+      checkCudaErrors(
+          cudaStreamAttachMemAsync(stream[0], t.result, 0, cudaMemAttachHost));
+      // necessary to ensure Async cudaStreamAttachMemAsync calls have finished
+      checkCudaErrors(cudaStreamSynchronize(stream[0]));
+      // call the host operation
+      gemv(t.size, t.size, 1.0, t.data, t.vector, 0.0, t.result);
+    } else {
+      // perform on device
+      printf("Task [%d], thread [%d] executing on device (%d)\n", t.id, tid,
+             t.size);
+      double one = 1.0;
+      double zero = 0.0;
+
+      // attach managed memory to my stream
+      checkCudaErrors(cublasSetStream(handle[tid + 1], stream[tid + 1]));
+      checkCudaErrors(cudaStreamAttachMemAsync(stream[tid + 1], t.data, 0,
+                                               cudaMemAttachSingle));
+      checkCudaErrors(cudaStreamAttachMemAsync(stream[tid + 1], t.vector, 0,
+                                               cudaMemAttachSingle));
+      checkCudaErrors(cudaStreamAttachMemAsync(stream[tid + 1], t.result, 0,
+                                               cudaMemAttachSingle));
+      // call the device operation
+      checkCudaErrors(cublasDgemv(handle[tid + 1], CUBLAS_OP_N, t.size, t.size,
+                                  &one, t.data, t.size, t.vector, 1, &zero,
+                                  t.result, 1));
+    }
+  }
+
+  pthread_exit(NULL);
+}
+#else
+template <typename T>
+void execute(Task<T> &t, cublasHandle_t *handle, cudaStream_t *stream,
+             int tid) {
+  if (t.size < 100) {
+    // perform on host
+    printf("Task [%d], thread [%d] executing on host (%d)\n", t.id, tid,
+           t.size);
+
+    // attach managed memory to a (dummy) stream to allow host access while the
+    // device is running
+    checkCudaErrors(
+        cudaStreamAttachMemAsync(stream[0], t.data, 0, cudaMemAttachHost));
+    checkCudaErrors(
+        cudaStreamAttachMemAsync(stream[0], t.vector, 0, cudaMemAttachHost));
+    checkCudaErrors(
+        cudaStreamAttachMemAsync(stream[0], t.result, 0, cudaMemAttachHost));
+    // necessary to ensure Async cudaStreamAttachMemAsync calls have finished
+    checkCudaErrors(cudaStreamSynchronize(stream[0]));
+    // call the host operation
+    gemv(t.size, t.size, 1.0, t.data, t.vector, 0.0, t.result);
+  } else {
+    // perform on device
+    printf("Task [%d], thread [%d] executing on device (%d)\n", t.id, tid,
+           t.size);
+    double one = 1.0;
+    double zero = 0.0;
+
+    // attach managed memory to my stream
+    checkCudaErrors(cublasSetStream(handle[tid + 1], stream[tid + 1]));
+    checkCudaErrors(cudaStreamAttachMemAsync(stream[tid + 1], t.data, 0,
+                                             cudaMemAttachSingle));
+    checkCudaErrors(cudaStreamAttachMemAsync(stream[tid + 1], t.vector, 0,
+                                             cudaMemAttachSingle));
+    checkCudaErrors(cudaStreamAttachMemAsync(stream[tid + 1], t.result, 0,
+                                             cudaMemAttachSingle));
+    // call the device operation
+    checkCudaErrors(cublasDgemv(handle[tid + 1], CUBLAS_OP_N, t.size, t.size,
+                                &one, t.data, t.size, t.vector, 1, &zero,
+                                t.result, 1));
+  }
+}
+#endif
+
+// populate a list of tasks with random sizes
+template <typename T>
+void initialise_tasks(std::vector<Task<T> > &TaskList) {
+  for (unsigned int i = 0; i < TaskList.size(); i++) {
+    // generate random size
+    int size;
+    size = std::max((int)(drand48() * 1000.0), 64);
+    TaskList[i].allocate(size, i);
+  }
+}
+
+int main(int argc, char **argv) {
+  // set device
+  cudaDeviceProp device_prop;
+  int dev_id = findCudaDevice(argc, (const char **)argv);
+  checkCudaErrors(cudaGetDeviceProperties(&device_prop, dev_id));
+
+  if (!device_prop.managedMemory) {
+    // This samples requires being run on a device that supports Unified Memory
+    fprintf(stderr, "Unified Memory not supported on this device\n");
+
+    exit(EXIT_WAIVED);
+  }
+
+  if (device_prop.computeMode == cudaComputeModeProhibited) {
+    // This sample requires being run with a default or process exclusive mode
+    fprintf(stderr,
+            "This sample requires a device in either default or process "
+            "exclusive mode\n");
+
+    exit(EXIT_WAIVED);
+  }
+
+  // randomise task sizes
+  int seed = (int)time(NULL);
+  srand48(seed);
+
+  // set number of threads
+  const int nthreads = 4;
+
+  // number of streams = number of threads
+  cudaStream_t *streams = new cudaStream_t[nthreads + 1];
+  cublasHandle_t *handles = new cublasHandle_t[nthreads + 1];
+
+  for (int i = 0; i < nthreads + 1; i++) {
+    checkCudaErrors(cudaStreamCreate(&streams[i]));
+    checkCudaErrors(cublasCreate(&handles[i]));
+  }
+
+  // create list of N tasks
+  unsigned int N = 40;
+  std::vector<Task<double> > TaskList(N);
+  initialise_tasks(TaskList);
+
+  printf("Executing tasks on host / device\n");
+
+// run through all tasks using threads and streams
+#ifdef USE_PTHREADS
+  pthread_t threads[nthreads];
+  threadData *InputToThreads = new threadData[nthreads];
+
+  for (int i = 0; i < nthreads; i++) {
+    checkCudaErrors(cudaSetDevice(dev_id));
+    InputToThreads[i].tid = i;
+    InputToThreads[i].streams = streams;
+    InputToThreads[i].handles = handles;
+
+    if ((TaskList.size() / nthreads) == 0) {
+      InputToThreads[i].taskSize = (TaskList.size() / nthreads);
+      InputToThreads[i].TaskListPtr =
+          &TaskList[i * (TaskList.size() / nthreads)];
+    } else {
+      if (i == nthreads - 1) {
+        InputToThreads[i].taskSize =
+            (TaskList.size() / nthreads) + (TaskList.size() % nthreads);
+        InputToThreads[i].TaskListPtr =
+            &TaskList[i * (TaskList.size() / nthreads) +
+                      (TaskList.size() % nthreads)];
+      } else {
+        InputToThreads[i].taskSize = (TaskList.size() / nthreads);
+        InputToThreads[i].TaskListPtr =
+            &TaskList[i * (TaskList.size() / nthreads)];
+      }
+    }
+
+    pthread_create(&threads[i], NULL, &execute, &InputToThreads[i]);
+  }
+  for (int i = 0; i < nthreads; i++) {
+    pthread_join(threads[i], NULL);
+  }
+#else
+  omp_set_num_threads(nthreads);
+#pragma omp parallel for schedule(dynamic)
+  for (int i = 0; i < TaskList.size(); i++) {
+    checkCudaErrors(cudaSetDevice(dev_id));
+    int tid = omp_get_thread_num();
+    execute(TaskList[i], handles, streams, tid);
+  }
+#endif
+
+  cudaDeviceSynchronize();
+
+  // Destroy CUDA Streams, cuBlas handles
+  for (int i = 0; i < nthreads + 1; i++) {
+    cudaStreamDestroy(streams[i]);
+    cublasDestroy(handles[i]);
+  }
+
+  // Free TaskList
+  std::vector<Task<double> >().swap(TaskList);
+
+  printf("All Done!\n");
+  exit(EXIT_SUCCESS);
+}

Samples/0_Introduction/UnifiedMemoryStreams/UnifiedMemoryStreams_vs2017.sln

@@ -1,7 +1,7 @@
 
-Microsoft Visual Studio Solution File, Format Version 14.00
-# Visual Studio 2015
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "UnifiedMemoryPerf", "UnifiedMemoryPerf_vs2015.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "UnifiedMemoryStreams", "UnifiedMemoryStreams_vs2017.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

Samples/0_Introduction/UnifiedMemoryStreams/UnifiedMemoryStreams_vs2017.vcxproj

@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>UnifiedMemoryStreams_vs2017</RootNamespace>
+    <ProjectName>UnifiedMemoryStreams</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(WindowsTargetPlatformVersion)'==''">
+    <LatestTargetPlatformVersion>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetLatestSDKTargetPlatformVersion('Windows', '10.0'))</LatestTargetPlatformVersion>
+    <WindowsTargetPlatformVersion Condition="'$(WindowsTargetPlatformVersion)' == ''">$(LatestTargetPlatformVersion)</WindowsTargetPlatformVersion>
+    <TargetPlatformVersion>$(WindowsTargetPlatformVersion)</TargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 12.5.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;$(CudaToolkitIncludeDir);</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cublas.lib;cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/UnifiedMemoryStreams.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;compute_89,sm_89;compute_90,sm_90;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+      <AdditionalCompilerOptions>/openmp</AdditionalCompilerOptions>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="UnifiedMemoryStreams.cu" />
+
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 12.5.targets" />
+  </ImportGroup>
+</Project>

Samples/0_Introduction/UnifiedMemoryStreams/UnifiedMemoryStreams_vs2019.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "UnifiedMemoryStreams", "UnifiedMemoryStreams_vs2019.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/0_Introduction/UnifiedMemoryStreams/UnifiedMemoryStreams_vs2019.vcxproj

@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>UnifiedMemoryStreams_vs2019</RootNamespace>
+    <ProjectName>UnifiedMemoryStreams</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 12.5.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;$(CudaToolkitIncludeDir);</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cublas.lib;cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/UnifiedMemoryStreams.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;compute_89,sm_89;compute_90,sm_90;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+      <AdditionalCompilerOptions>/openmp</AdditionalCompilerOptions>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="UnifiedMemoryStreams.cu" />
+
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 12.5.targets" />
+  </ImportGroup>
+</Project>

Samples/0_Introduction/UnifiedMemoryStreams/UnifiedMemoryStreams_vs2022.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2022
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "UnifiedMemoryStreams", "UnifiedMemoryStreams_vs2022.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/0_Introduction/UnifiedMemoryStreams/UnifiedMemoryStreams_vs2022.vcxproj

@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>UnifiedMemoryStreams_vs2022</RootNamespace>
+    <ProjectName>UnifiedMemoryStreams</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v143</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 12.5.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;$(CudaToolkitIncludeDir);</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cublas.lib;cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/UnifiedMemoryStreams.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;compute_89,sm_89;compute_90,sm_90;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+      <AdditionalCompilerOptions>/openmp</AdditionalCompilerOptions>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="UnifiedMemoryStreams.cu" />
+
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 12.5.targets" />
+  </ImportGroup>
+</Project>

Samples/0_Introduction/asyncAPI/.vscode/c_cpp_properties.json

@@ -0,0 +1,18 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/../../../Common"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/local/cuda/bin/nvcc",
+            "cStandard": "gnu17",
+            "cppStandard": "gnu++14",
+            "intelliSenseMode": "linux-gcc-x64",
+            "configurationProvider": "ms-vscode.makefile-tools"
+        }
+    ],
+    "version": 4
+}

Samples/0_Introduction/asyncAPI/.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "nvidia.nsight-vscode-edition",
+        "ms-vscode.cpptools",
+        "ms-vscode.makefile-tools"
+    ]
+}

Samples/0_Introduction/asyncAPI/.vscode/launch.json

@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/asyncAPI"
+        }
+    ]
+}

Samples/0_Introduction/asyncAPI/.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "sample",
+            "type": "shell",
+            "command": "make dbg=1",
+            "problemMatcher": ["$nvcc"],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}

Samples/0_Introduction/asyncAPI/Makefile

@@ -0,0 +1,358 @@
+################################################################################
+# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#  * Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#  * Neither the name of NVIDIA CORPORATION nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+################################################################################
+#
+# Makefile project only supported on Mac OS X and Linux Platforms)
+#
+################################################################################
+
+# Location of the CUDA Toolkit
+CUDA_PATH ?= /usr/local/cuda
+
+##############################
+# start deprecated interface #
+##############################
+ifeq ($(x86_64),1)
+    $(info WARNING - x86_64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=x86_64 instead)
+    TARGET_ARCH ?= x86_64
+endif
+ifeq ($(ARMv7),1)
+    $(info WARNING - ARMv7 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=armv7l instead)
+    TARGET_ARCH ?= armv7l
+endif
+ifeq ($(aarch64),1)
+    $(info WARNING - aarch64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=aarch64 instead)
+    TARGET_ARCH ?= aarch64
+endif
+ifeq ($(ppc64le),1)
+    $(info WARNING - ppc64le variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=ppc64le instead)
+    TARGET_ARCH ?= ppc64le
+endif
+ifneq ($(GCC),)
+    $(info WARNING - GCC variable has been deprecated)
+    $(info WARNING - please use HOST_COMPILER=$(GCC) instead)
+    HOST_COMPILER ?= $(GCC)
+endif
+ifneq ($(abi),)
+    $(error ERROR - abi variable has been removed)
+endif
+############################
+# end deprecated interface #
+############################
+
+# architecture
+HOST_ARCH   := $(shell uname -m)
+TARGET_ARCH ?= $(HOST_ARCH)
+ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l))
+    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le))
+            TARGET_SIZE := 64
+        else ifneq (,$(filter $(TARGET_ARCH),armv7l))
+            TARGET_SIZE := 32
+        endif
+    else
+        TARGET_SIZE := $(shell getconf LONG_BIT)
+    endif
+else
+    $(error ERROR - unsupported value $(TARGET_ARCH) for TARGET_ARCH!)
+endif
+
+# sbsa and aarch64 systems look similar. Need to differentiate them at host level for now.
+ifeq ($(HOST_ARCH),aarch64)
+    ifeq ($(CUDA_PATH)/targets/sbsa-linux,$(shell ls -1d $(CUDA_PATH)/targets/sbsa-linux 2>/dev/null))
+        HOST_ARCH := sbsa
+        TARGET_ARCH := sbsa
+    endif
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 x86_64-sbsa x86_64-ppc64le))
+        $(error ERROR - cross compiling from $(HOST_ARCH) to $(TARGET_ARCH) is not supported!)
+    endif
+endif
+
+# When on native aarch64 system with userspace of 32-bit, change TARGET_ARCH to armv7l
+ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_SIZE),aarch64-aarch64-32)
+    TARGET_ARCH = armv7l
+endif
+
+# operating system
+HOST_OS   := $(shell uname -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+TARGET_OS ?= $(HOST_OS)
+ifeq (,$(filter $(TARGET_OS),linux darwin qnx android))
+    $(error ERROR - unsupported value $(TARGET_OS) for TARGET_OS!)
+endif
+
+# host compiler
+ifdef HOST_COMPILER
+ CUSTOM_HOST_COMPILER = 1
+endif
+
+ifeq ($(TARGET_OS),darwin)
+    ifeq ($(shell expr `xcodebuild -version | grep -i xcode | awk '{print $$2}' | cut -d'.' -f1` \>= 5),1)
+        HOST_COMPILER ?= clang++
+    endif
+else ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        ifeq ($(TARGET_OS),linux)
+            HOST_COMPILER ?= arm-linux-gnueabihf-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/arm-unknown-nto-qnx6.6.0eabi-g++
+        else ifeq ($(TARGET_OS),android)
+            HOST_COMPILER ?= arm-linux-androideabi-g++
+        endif
+    else ifeq ($(TARGET_ARCH),aarch64)
+        ifeq ($(TARGET_OS), linux)
+            HOST_COMPILER ?= aarch64-linux-gnu-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/q++
+        else ifeq ($(TARGET_OS), android)
+            HOST_COMPILER ?= aarch64-linux-android-clang++
+        endif
+    else ifeq ($(TARGET_ARCH),sbsa)
+        HOST_COMPILER ?= aarch64-linux-gnu-g++
+    else ifeq ($(TARGET_ARCH),ppc64le)
+        HOST_COMPILER ?= powerpc64le-linux-gnu-g++
+    endif
+endif
+HOST_COMPILER ?= g++
+NVCC          := $(CUDA_PATH)/bin/nvcc -ccbin $(HOST_COMPILER)
+
+# internal flags
+NVCCFLAGS   := -m${TARGET_SIZE}
+CCFLAGS     :=
+LDFLAGS     :=
+
+# build flags
+
+# Link flag for customized HOST_COMPILER with gcc realpath
+GCC_PATH := $(shell which gcc)
+ifeq ($(CUSTOM_HOST_COMPILER),1)
+    ifneq ($(filter /%,$(HOST_COMPILER)),)
+        ifneq ($(findstring gcc,$(HOST_COMPILER)),)
+            ifneq ($(GCC_PATH),$(HOST_COMPILER))
+                LDFLAGS += -lstdc++
+            endif
+        endif
+    endif
+endif
+
+ifeq ($(TARGET_OS),darwin)
+    LDFLAGS += -rpath $(CUDA_PATH)/lib
+    CCFLAGS += -arch $(HOST_ARCH)
+else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+    LDFLAGS += --dynamic-linker=/lib/ld-linux-armhf.so.3
+    CCFLAGS += -mfloat-abi=hard
+else ifeq ($(TARGET_OS),android)
+    LDFLAGS += -pie
+    CCFLAGS += -fpie -fpic -fexceptions
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib -L$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib/aarch64-linux-gnu -L$(TARGET_FS)/lib/aarch64-linux-gnu
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib -L$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/aarch64-linux-gnu -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+            LDFLAGS += --unresolved-symbols=ignore-in-shared-libs
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include/libdrm
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu -I$(TARGET_FS)/usr/include/aarch64-linux-gnu
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+        NVCCFLAGS += -D_QNX_SOURCE
+        NVCCFLAGS += --qpp-config 8.3.0,gcc_ntoaarch64le
+        CCFLAGS += -DWIN_INTERFACE_CUSTOM -I/usr/include/aarch64-qnx-gnu
+        LDFLAGS += -lsocket
+        LDFLAGS += -L/usr/lib/aarch64-qnx-gnu
+        CCFLAGS += "-Wl\,-rpath-link\,/usr/lib/aarch64-qnx-gnu"
+        ifdef TARGET_OVERRIDE
+            LDFLAGS += -lslog2
+        endif
+
+        ifneq ($(TARGET_FS),)
+            LDFLAGS += -L$(TARGET_FS)/usr/lib
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/lib"
+            LDFLAGS += -L$(TARGET_FS)/usr/libnvidia
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/libnvidia"
+            CCFLAGS += -I$(TARGET_FS)/../include
+        endif
+    endif
+endif
+
+ifdef TARGET_OVERRIDE # cuda toolkit targets override
+    NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
+endif
+
+# Install directory of different arch
+CUDA_INSTALL_TARGET_DIR :=
+ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-gnueabihf/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/sbsa-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
+else ifeq ($(TARGET_ARCH),ppc64le)
+    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
+endif
+
+# Debug build flags
+ifeq ($(dbg),1)
+      NVCCFLAGS += -g -G
+      BUILD_TYPE := debug
+else
+      BUILD_TYPE := release
+endif
+
+ALL_CCFLAGS :=
+ALL_CCFLAGS += $(NVCCFLAGS)
+ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
+
+SAMPLE_ENABLED := 1
+
+ALL_LDFLAGS :=
+ALL_LDFLAGS += $(ALL_CCFLAGS)
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
+
+# Common includes and paths for CUDA
+INCLUDES  := -I../../../Common
+LIBRARIES :=
+
+################################################################################
+
+# Gencode arguments
+ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64 sbsa))
+SMS ?= 53 61 70 72 75 80 86 87 90
+else
+SMS ?= 50 52 60 61 70 75 80 86 89 90
+endif
+
+ifeq ($(SMS),)
+$(info >>> WARNING - no SM architectures have been specified - waiving sample <<<)
+SAMPLE_ENABLED := 0
+endif
+
+ifeq ($(GENCODE_FLAGS),)
+# Generate SASS code for each SM architecture listed in $(SMS)
+$(foreach sm,$(SMS),$(eval GENCODE_FLAGS += -gencode arch=compute_$(sm),code=sm_$(sm)))
+
+# Generate PTX code from the highest SM architecture in $(SMS) to guarantee forward-compatibility
+HIGHEST_SM := $(lastword $(sort $(SMS)))
+ifneq ($(HIGHEST_SM),)
+GENCODE_FLAGS += -gencode arch=compute_$(HIGHEST_SM),code=compute_$(HIGHEST_SM)
+endif
+endif
+
+ALL_CCFLAGS += --threads 0 --std=c++11
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: asyncAPI
+
+check.deps:
+ifeq ($(SAMPLE_ENABLED),0)
+	@echo "Sample will be waived due to the above missing dependencies"
+else
+	@echo "Sample is ready - all dependencies have been met"
+endif
+
+asyncAPI.o:asyncAPI.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+asyncAPI: asyncAPI.o
+	$(EXEC) $(NVCC) $(ALL_LDFLAGS) $(GENCODE_FLAGS) -o $@ $+ $(LIBRARIES)
+	$(EXEC) mkdir -p ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+	$(EXEC) cp $@ ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+
+run: build
+	$(EXEC) ./asyncAPI
+
+testrun: build
+	$(EXEC) ./asyncAPI --dummy-test-param
+
+clean:
+	rm -f asyncAPI asyncAPI.o
+	rm -rf ../../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/asyncAPI
+
+clobber: clean

Samples/0_Introduction/asyncAPI/NsightEclipse.xml

@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>asyncAPI</name>
+  <cuda_api_list>
+    <toolkit>cudaProfilerStop</toolkit>
+    <toolkit>cudaMalloc</toolkit>
+    <toolkit>cudaMemcpyAsync</toolkit>
+    <toolkit>cudaFree</toolkit>
+    <toolkit>cudaMallocHost</toolkit>
+    <toolkit>cudaProfilerStart</toolkit>
+    <toolkit>cudaDeviceSynchronize</toolkit>
+    <toolkit>cudaEventRecord</toolkit>
+    <toolkit>cudaFreeHost</toolkit>
+    <toolkit>cudaMemset</toolkit>
+    <toolkit>cudaEventDestroy</toolkit>
+    <toolkit>cudaEventQuery</toolkit>
+    <toolkit>cudaEventElapsedTime</toolkit>
+    <toolkit>cudaGetDeviceProperties</toolkit>
+    <toolkit>cudaEventCreate</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[This sample illustrates the usage of CUDA events for both GPU timing and overlapping CPU and GPU execution. Events are inserted into a stream of CUDA calls. Since CUDA stream calls are asynchronous, the CPU can perform computations while GPU is executing (including DMA memcopies between the host and device). CPU can query CUDA events to determine whether GPU has completed tasks.]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="basic">Asynchronous Data Transfers</concept>
+    <concept level="basic">CUDA Streams and Events</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>GPGPU</keyword>
+  </keywords>
+  <libraries>
+  </libraries>
+  <librarypaths>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>asyncAPI.cu</primary_file>
+  <qatests>
+    <qatest>--dummy-test-param</qatest>
+  </qatests>
+  <scopes>
+    <scope>1:CUDA Basic Topics</scope>
+    <scope>1:Performance Strategies</scope>
+  </scopes>
+  <sm-arch>sm50</sm-arch>
+  <sm-arch>sm52</sm-arch>
+  <sm-arch>sm53</sm-arch>
+  <sm-arch>sm60</sm-arch>
+  <sm-arch>sm61</sm-arch>
+  <sm-arch>sm70</sm-arch>
+  <sm-arch>sm72</sm-arch>
+  <sm-arch>sm75</sm-arch>
+  <sm-arch>sm80</sm-arch>
+  <sm-arch>sm86</sm-arch>
+  <sm-arch>sm87</sm-arch>
+  <sm-arch>sm89</sm-arch>
+  <sm-arch>sm90</sm-arch>
+  <supported_envs>
+    <env>
+      <arch>x86_64</arch>
+      <platform>linux</platform>
+    </env>
+    <env>
+      <platform>windows7</platform>
+    </env>
+    <env>
+      <arch>x86_64</arch>
+      <platform>macosx</platform>
+    </env>
+    <env>
+      <arch>arm</arch>
+    </env>
+    <env>
+      <arch>sbsa</arch>
+    </env>
+    <env>
+      <arch>ppc64le</arch>
+      <platform>linux</platform>
+    </env>
+  </supported_envs>
+  <supported_sm_architectures>
+    <include>all</include>
+  </supported_sm_architectures>
+  <title>asyncAPI</title>
+  <type>exe</type>
+</entry>

Samples/0_Introduction/asyncAPI/README.md

@@ -0,0 +1,70 @@
+# asyncAPI - asyncAPI
+
+## Description
+
+This sample illustrates the usage of CUDA events for both GPU timing and overlapping CPU and GPU execution. Events are inserted into a stream of CUDA calls. Since CUDA stream calls are asynchronous, the CPU can perform computations while GPU is executing (including DMA memcopies between the host and device). CPU can query CUDA events to determine whether GPU has completed tasks.
+
+## Key Concepts
+
+Asynchronous Data Transfers, CUDA Streams and Events
+
+## Supported SM Architectures
+
+[SM 5.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 5.2 ](https://developer.nvidia.com/cuda-gpus)  [SM 5.3 ](https://developer.nvidia.com/cuda-gpus)  [SM 6.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 6.1 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.2 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.5 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.6 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.7 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.9 ](https://developer.nvidia.com/cuda-gpus)  [SM 9.0 ](https://developer.nvidia.com/cuda-gpus)
+
+## Supported OSes
+
+Linux, Windows
+
+## Supported CPU Architecture
+
+x86_64, ppc64le, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaProfilerStop, cudaMalloc, cudaMemcpyAsync, cudaFree, cudaMallocHost, cudaProfilerStart, cudaDeviceSynchronize, cudaEventRecord, cudaFreeHost, cudaMemset, cudaEventDestroy, cudaEventQuery, cudaEventElapsedTime, cudaGetDeviceProperties, cudaEventCreate
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit 12.5](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+
+## Build and Run
+
+### Windows
+The Windows samples are built using the Visual Studio IDE. Solution files (.sln) are provided for each supported version of Visual Studio, using the format:
+```
+*_vs<version>.sln - for Visual Studio <version>
+```
+Each individual sample has its own set of solution files in its directory:
+
+To build/examine all the samples at once, the complete solution files should be used. To build/examine a single sample, the individual sample solution files should be used.
+> **Note:** Some samples require that the Microsoft DirectX SDK (June 2010 or newer) be installed and that the VC++ directory paths are properly set up (**Tools > Options...**). Check DirectX Dependencies section for details."
+
+### Linux
+The Linux samples are built using makefiles. To use the makefiles, change the current directory to the sample directory you wish to build, and run make:
+```
+$ cd <sample_dir>
+$ make
+```
+The samples makefiles can take advantage of certain options:
+*  **TARGET_ARCH=<arch>** - cross-compile targeting a specific architecture. Allowed architectures are x86_64, ppc64le, armv7l.
+    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
+`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=ppc64le` <br/> `$ make TARGET_ARCH=armv7l` <br/>
+    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
+*   **dbg=1** - build with debug symbols
+    ```
+    $ make dbg=1
+    ```
+*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
+    ```
+    $ make SMS="50 60"
+    ```
+
+*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
+```
+    $ make HOST_COMPILER=g++
+```
+
+## References (for more details)
+

Samples/0_Introduction/asyncAPI/asyncAPI.cu

@@ -0,0 +1,142 @@
+/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * This sample illustrates the usage of CUDA events for both GPU timing and
+ * overlapping CPU and GPU execution.  Events are inserted into a stream
+ * of CUDA calls.  Since CUDA stream calls are asynchronous, the CPU can
+ * perform computations while GPU is executing (including DMA memcopies
+ * between the host and device).  CPU can query CUDA events to determine
+ * whether GPU has completed tasks.
+ */
+
+// includes, system
+#include <stdio.h>
+
+// includes CUDA Runtime
+#include <cuda_runtime.h>
+#include <cuda_profiler_api.h>
+
+// includes, project
+#include <helper_cuda.h>
+#include <helper_functions.h>  // helper utility functions
+
+__global__ void increment_kernel(int *g_data, int inc_value) {
+  int idx = blockIdx.x * blockDim.x + threadIdx.x;
+  g_data[idx] = g_data[idx] + inc_value;
+}
+
+bool correct_output(int *data, const int n, const int x) {
+  for (int i = 0; i < n; i++)
+    if (data[i] != x) {
+      printf("Error! data[%d] = %d, ref = %d\n", i, data[i], x);
+      return false;
+    }
+
+  return true;
+}
+
+int main(int argc, char *argv[]) {
+  int devID;
+  cudaDeviceProp deviceProps;
+
+  printf("[%s] - Starting...\n", argv[0]);
+
+  // This will pick the best possible CUDA capable device
+  devID = findCudaDevice(argc, (const char **)argv);
+
+  // get device name
+  checkCudaErrors(cudaGetDeviceProperties(&deviceProps, devID));
+  printf("CUDA device [%s]\n", deviceProps.name);
+
+  int n = 16 * 1024 * 1024;
+  int nbytes = n * sizeof(int);
+  int value = 26;
+
+  // allocate host memory
+  int *a = 0;
+  checkCudaErrors(cudaMallocHost((void **)&a, nbytes));
+  memset(a, 0, nbytes);
+
+  // allocate device memory
+  int *d_a = 0;
+  checkCudaErrors(cudaMalloc((void **)&d_a, nbytes));
+  checkCudaErrors(cudaMemset(d_a, 255, nbytes));
+
+  // set kernel launch configuration
+  dim3 threads = dim3(512, 1);
+  dim3 blocks = dim3(n / threads.x, 1);
+
+  // create cuda event handles
+  cudaEvent_t start, stop;
+  checkCudaErrors(cudaEventCreate(&start));
+  checkCudaErrors(cudaEventCreate(&stop));
+
+  StopWatchInterface *timer = NULL;
+  sdkCreateTimer(&timer);
+  sdkResetTimer(&timer);
+
+  checkCudaErrors(cudaDeviceSynchronize());
+  float gpu_time = 0.0f;
+
+  // asynchronously issue work to the GPU (all to stream 0)
+  checkCudaErrors(cudaProfilerStart());
+  sdkStartTimer(&timer);
+  cudaEventRecord(start, 0);
+  cudaMemcpyAsync(d_a, a, nbytes, cudaMemcpyHostToDevice, 0);
+  increment_kernel<<<blocks, threads, 0, 0>>>(d_a, value);
+  cudaMemcpyAsync(a, d_a, nbytes, cudaMemcpyDeviceToHost, 0);
+  cudaEventRecord(stop, 0);
+  sdkStopTimer(&timer);
+  checkCudaErrors(cudaProfilerStop());
+
+  // have CPU do some work while waiting for stage 1 to finish
+  unsigned long int counter = 0;
+
+  while (cudaEventQuery(stop) == cudaErrorNotReady) {
+    counter++;
+  }
+
+  checkCudaErrors(cudaEventElapsedTime(&gpu_time, start, stop));
+
+  // print the cpu and gpu times
+  printf("time spent executing by the GPU: %.2f\n", gpu_time);
+  printf("time spent by CPU in CUDA calls: %.2f\n", sdkGetTimerValue(&timer));
+  printf("CPU executed %lu iterations while waiting for GPU to finish\n",
+         counter);
+
+  // check the output for correctness
+  bool bFinalResults = correct_output(a, n, value);
+
+  // release resources
+  checkCudaErrors(cudaEventDestroy(start));
+  checkCudaErrors(cudaEventDestroy(stop));
+  checkCudaErrors(cudaFreeHost(a));
+  checkCudaErrors(cudaFree(d_a));
+
+  exit(bFinalResults ? EXIT_SUCCESS : EXIT_FAILURE);
+}

Samples/0_Introduction/asyncAPI/asyncAPI_vs2017.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "asyncAPI", "asyncAPI_vs2017.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Samples/0_Introduction/asyncAPI/asyncAPI_vs2017.vcxproj

@@ -0,0 +1,112 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>asyncAPI_vs2017</RootNamespace>
+    <ProjectName>asyncAPI</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(WindowsTargetPlatformVersion)'==''">
+    <LatestTargetPlatformVersion>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetLatestSDKTargetPlatformVersion('Windows', '10.0'))</LatestTargetPlatformVersion>
+    <WindowsTargetPlatformVersion Condition="'$(WindowsTargetPlatformVersion)' == ''">$(LatestTargetPlatformVersion)</WindowsTargetPlatformVersion>
+    <TargetPlatformVersion>$(WindowsTargetPlatformVersion)</TargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 12.5.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/asyncAPI.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;compute_89,sm_89;compute_90,sm_90;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819"  --threads 0 </AdditionalOptions>
+      <Include>./;../../../Common</Include>
+      <Defines>WIN32</Defines>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <CudaCompile Include="asyncAPI.cu" />
+
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 12.5.targets" />
+  </ImportGroup>
+</Project>

Samples/0_Introduction/asyncAPI/asyncAPI_vs2019.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "asyncAPI", "asyncAPI_vs2019.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal