add and update samples for CUDA 11.5

2026-10-23 21:28:17 +08:00 · 2021-10-21 16:34:49 +05:30
parent 3342d604fe
commit 1f76a2d110
2796 changed files with 1511725 additions and 827 deletions
--- a/Samples/marchingCubes/.vscode/c_cpp_properties.json
+++ b/Samples/marchingCubes/.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
+}
--- a/Samples/marchingCubes/.vscode/extensions.json
+++ b/Samples/marchingCubes/.vscode/extensions.json
@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "nvidia.nsight-vscode-edition",
+        "ms-vscode.cpptools",
+        "ms-vscode.makefile-tools"
+    ]
+}
--- a/Samples/marchingCubes/.vscode/launch.json
+++ b/Samples/marchingCubes/.vscode/launch.json
@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/marchingCubes"
+        }
+    ]
+}
--- a/Samples/marchingCubes/.vscode/tasks.json
+++ b/Samples/marchingCubes/.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
+            }
+        }
+    ]
+}
--- a/Samples/marchingCubes/Makefile
+++ b/Samples/marchingCubes/Makefile
@@ -0,0 +1,385 @@
+################################################################################
+# Copyright (c) 2019, 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
+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
+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 += --qpp-config 5.4.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
+
+# This sample is not supported on QNX
+ifeq ($(TARGET_OS),qnx)
+  $(info >>> WARNING - marchingCubes 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 :=
+
+################################################################################
+
+# Makefile include to help find GL Libraries
+include ./findgllib.mk
+
+# OpenGL specific libraries
+ifeq ($(TARGET_OS),darwin)
+ # Mac OSX specific libraries and paths to include
+ LIBRARIES += -L/System/Library/Frameworks/OpenGL.framework/Libraries
+ LIBRARIES += -lGL -lGLU
+ ALL_LDFLAGS += -Xlinker -framework -Xlinker GLUT
+else
+ LIBRARIES += $(GLLINK)
+ LIBRARIES += -lGL -lGLU -lglut
+endif
+
+#Detect if installed version of GCC supports required C++11
+ifeq ($(TARGET_OS),linux)
+    empty :=
+    space := $(empty) $(empty)
+    GCCVERSIONSTRING := $(shell expr `$(HOST_COMPILER) -dumpversion`)
+#Create version number without "."
+    GCCVERSION := $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f1 -d.)
+    GCCVERSION += $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f2 -d.)
+    GCCVERSION += $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f3 -d.)
+# Make sure the version number has at least 3 decimals
+    GCCVERSION += 00
+# Remove spaces from the version number
+    GCCVERSION := $(subst $(space),$(empty),$(GCCVERSION))
+#$(warning $(GCCVERSION))
+
+    IS_MIN_VERSION := $(shell expr `echo $(GCCVERSION)` \>= 51000)
+
+    ifeq ($(IS_MIN_VERSION), 1)
+        $(info >>> GCC Version is greater or equal to 5.1.0 <<<)
+    else
+        $(info >>> Waiving build. Minimum GCC version required is 5.1.0<<<)
+        SAMPLE_ENABLED := 0
+    endif
+endif
+
+# Gencode arguments
+ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64))
+SMS ?= 35 37 50 52 60 61 70 72 75 80 86
+else
+SMS ?= 35 37 50 52 60 61 70 75 80 86
+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 += --std=c++14 --threads 0
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: marchingCubes
+
+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
+
+marchingCubes.o:marchingCubes.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+marchingCubes_kernel.o:marchingCubes_kernel.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+marchingCubes: marchingCubes.o marchingCubes_kernel.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) ./marchingCubes
+
+clean:
+	rm -f marchingCubes marchingCubes.o marchingCubes_kernel.o
+	rm -rf ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/marchingCubes
+
+clobber: clean
--- a/Samples/marchingCubes/NsightEclipse.xml
+++ b/Samples/marchingCubes/NsightEclipse.xml
@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>marchingCubes</name>
+  <cflags>
+    <flag>--std=c++14</flag>
+  </cflags>
+  <cuda_api_list>
+    <toolkit>cudaGraphicsMapResources</toolkit>
+    <toolkit>cudaGraphicsUnmapResources</toolkit>
+    <toolkit>cudaGraphicsResourceGetMappedPointer</toolkit>
+    <toolkit>cudaGraphicsRegisterResource</toolkit>
+    <toolkit>cudaGraphicsGLRegisterBuffer</toolkit>
+    <toolkit>cudaGraphicsUnregisterResource</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[This sample extracts a geometric isosurface from a volume dataset using the marching cubes algorithm. It uses the scan (prefix sum) function from the Thrust library to perform stream compaction.]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <files>
+    <file>..\..\doc\Thrust_license.txt</file>
+    <file>data\Bucky.raw</file>
+    <file>data\ref_march_cubes.ppm</file>
+    <file>data\posArray.bin</file>
+    <file>data\normalArray.bin</file>
+    <file>data\compVoxelArray.bin</file>
+  </files>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="advanced">OpenGL Graphics Interop</concept>
+    <concept level="advanced">Vertex Buffers</concept>
+    <concept level="advanced">3D Graphics</concept>
+    <concept level="advanced">Physically Based Simulation</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>OpenGL</keyword>
+    <keyword>isosurface</keyword>
+    <keyword>marching cubes</keyword>
+    <keyword>openGL</keyword>
+    <keyword>CPP14</keyword>
+  </keywords>
+  <libraries>
+    <library>GLU</library>
+    <library>GL</library>
+    <library framework="true" os="macosx">GLUT</library>
+    <library os="linux">GLEW</library>
+    <library os="linux">glut</library>
+    <library os="linux">X11</library>
+  </libraries>
+  <librarypaths>
+    <path arch="x86_64" os="linux">../../common/lib/linux/x86_64</path>
+    <path arch="armv7l" os="linux">../../common/lib/linux/armv7l</path>
+    <path os="macosx">../../common/lib/darwin</path>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>marchingCubes.cpp</primary_file>
+  <qatests>
+    <qatest>-dump=0 -file=posArray.bin</qatest>
+    <qatest>-dump=1 -file=normalArray.bin</qatest>
+    <qatest>-dump=2 -file=compVoxelArray.bin</qatest>
+  </qatests>
+  <required_dependencies>
+    <dependency>X11</dependency>
+    <dependency>GL</dependency>
+  </required_dependencies>
+  <scopes>
+    <scope>2:Graphics Interop</scope>
+    <scope>1:CUDA Advanced Topics</scope>
+    <scope>3:Physically-Based Simulation</scope>
+  </scopes>
+  <sm-arch>sm35</sm-arch>
+  <sm-arch>sm37</sm-arch>
+  <sm-arch>sm50</sm-arch>
+  <sm-arch>sm52</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>
+  <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>
+  </supported_envs>
+  <supported_sm_architectures>
+    <include>all</include>
+  </supported_sm_architectures>
+  <title>Marching Cubes Isosurfaces</title>
+  <type>exe</type>
+</entry>
--- a/Samples/marchingCubes/README.md
+++ b/Samples/marchingCubes/README.md
@@ -0,0 +1,74 @@
+# marchingCubes - Marching Cubes Isosurfaces
+
+## Description
+
+This sample extracts a geometric isosurface from a volume dataset using the marching cubes algorithm. It uses the scan (prefix sum) function from the Thrust library to perform stream compaction.
+
+## Key Concepts
+
+OpenGL Graphics Interop, Vertex Buffers, 3D Graphics, Physically Based Simulation
+
+## Supported SM Architectures
+
+[SM 3.5 ](https://developer.nvidia.com/cuda-gpus)  [SM 3.7 ](https://developer.nvidia.com/cuda-gpus)  [SM 5.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 5.2 ](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)
+
+## Supported OSes
+
+Linux, Windows
+
+## Supported CPU Architecture
+
+x86_64, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaGraphicsMapResources, cudaGraphicsUnmapResources, cudaGraphicsResourceGetMappedPointer, cudaGraphicsRegisterResource, cudaGraphicsGLRegisterBuffer, cudaGraphicsUnregisterResource
+
+## Dependencies needed to build/run
+[X11](../../README.md#x11), [GL](../../README.md#gl)
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit 11.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, 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=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)
+
--- a/Samples/marchingCubes/data/Bucky.raw
+++ b/Samples/marchingCubes/data/Bucky.raw
--- a/Samples/marchingCubes/data/compVoxelArray.bin
+++ b/Samples/marchingCubes/data/compVoxelArray.bin
--- a/Samples/marchingCubes/data/normalArray.bin
+++ b/Samples/marchingCubes/data/normalArray.bin
--- a/Samples/marchingCubes/data/posArray.bin
+++ b/Samples/marchingCubes/data/posArray.bin
--- a/Samples/marchingCubes/data/ref_march_cubes.ppm
+++ b/Samples/marchingCubes/data/ref_march_cubes.ppm
--- a/Samples/marchingCubes/defines.h
+++ b/Samples/marchingCubes/defines.h
@@ -0,0 +1,49 @@
+/* Copyright (c) 2021, 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 _DEFINES_H_
+#define _DEFINES_H_
+
+typedef unsigned int uint;
+typedef unsigned char uchar;
+
+// if SAMPLE_VOLUME is 0, an implicit dataset is generated. If 1, a voxelized
+// dataset is loaded from file
+#define SAMPLE_VOLUME 1
+
+// Using shared to store computed vertices and normals during triangle
+// generation
+// improves performance
+#define USE_SHARED 1
+
+// The number of threads to use for triangle generation (limited by shared
+// memory size)
+#define NTHREADS 32
+
+#define SKIP_EMPTY_VOXELS 1
+
+#endif
--- a/Samples/marchingCubes/doc/screenshot_lg.png
+++ b/Samples/marchingCubes/doc/screenshot_lg.png
--- a/Samples/marchingCubes/doc/screenshot_md.png
+++ b/Samples/marchingCubes/doc/screenshot_md.png
--- a/Samples/marchingCubes/doc/screenshot_sm.png
+++ b/Samples/marchingCubes/doc/screenshot_sm.png
--- a/Samples/marchingCubes/findgllib.mk
+++ b/Samples/marchingCubes/findgllib.mk
@@ -0,0 +1,145 @@
+################################################################################
+# Copyright (c) 2020, 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.
+#
+################################################################################
+#
+#  findgllib.mk is used to find the necessary GL Libraries for specific distributions
+#               this is supported on Mac OSX and Linux Platforms
+#
+################################################################################
+
+# Determine OS platform and unix distribution
+ifeq ("$(TARGET_OS)","linux")
+   # first search lsb_release
+   DISTRO  := $(shell lsb_release -i -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+   ifeq ("$(DISTRO)","")
+     # second search and parse /etc/issue
+     DISTRO := $(shell awk '{print $$1}' /etc/issue | tr -d "[:space:]" | sed -e "/^$$/d" | tr "[:upper:]" "[:lower:]")
+     # ensure data from /etc/issue is valid
+     ifeq (,$(filter $(DISTRO),ubuntu fedora red rhel centos suse))
+       DISTRO := 
+     endif
+     ifeq ("$(DISTRO)","")
+       # third, we can search in /etc/os-release or /etc/{distro}-release
+       DISTRO := $(shell awk '/ID/' /etc/*-release | sed 's/ID=//' | grep -v "VERSION" | grep -v "ID" | grep -v "DISTRIB")
+     endif
+   endif
+endif
+
+ifeq ("$(TARGET_OS)","linux")
+    # $(info) >> findgllib.mk -> LINUX path <<<)
+    # Each set of Linux Distros have different paths for where to find their OpenGL libraries reside
+    UBUNTU = $(shell echo $(DISTRO) | grep -i ubuntu      >/dev/null 2>&1; echo $$?)
+    FEDORA = $(shell echo $(DISTRO) | grep -i fedora      >/dev/null 2>&1; echo $$?)
+    RHEL   = $(shell echo $(DISTRO) | grep -i 'red\|rhel' >/dev/null 2>&1; echo $$?)
+    CENTOS = $(shell echo $(DISTRO) | grep -i centos      >/dev/null 2>&1; echo $$?)
+    SUSE   = $(shell echo $(DISTRO) | grep -i 'suse\|sles' >/dev/null 2>&1; echo $$?)
+    ifeq ("$(UBUNTU)","0")
+      ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        GLPATH := /usr/arm-linux-gnueabihf/lib
+        GLLINK := -L/usr/arm-linux-gnueabihf/lib
+        ifneq ($(TARGET_FS),) 
+          GLPATH += $(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+          GLLINK += -L$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif 
+      else ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-aarch64)
+        GLPATH := /usr/aarch64-linux-gnu/lib
+        GLLINK := -L/usr/aarch64-linux-gnu/lib
+        ifneq ($(TARGET_FS),) 
+          GLPATH += $(TARGET_FS)/usr/lib
+          GLPATH += $(TARGET_FS)/usr/lib/aarch64-linux-gnu
+          GLLINK += -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+        endif 
+      else ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-ppc64le)
+        GLPATH := /usr/powerpc64le-linux-gnu/lib
+        GLLINK := -L/usr/powerpc64le-linux-gnu/lib
+      else
+        UBUNTU_PKG_NAME = $(shell which dpkg >/dev/null 2>&1 && dpkg -l 'nvidia-*' | grep '^ii' | awk '{print $$2}' | head -1)
+        ifneq ("$(UBUNTU_PKG_NAME)","")
+          GLPATH    ?= /usr/lib/$(UBUNTU_PKG_NAME)
+          GLLINK    ?= -L/usr/lib/$(UBUNTU_PKG_NAME)
+        endif
+
+        DFLT_PATH ?= /usr/lib
+      endif
+    endif
+    ifeq ("$(SUSE)","0")
+      GLPATH    ?= /usr/X11R6/lib64
+      GLLINK    ?= -L/usr/X11R6/lib64
+      DFLT_PATH ?= /usr/lib64
+    endif
+    ifeq ("$(FEDORA)","0")
+      GLPATH    ?= /usr/lib64/nvidia
+      GLLINK    ?= -L/usr/lib64/nvidia
+      DFLT_PATH ?= /usr/lib64
+    endif
+    ifeq ("$(RHEL)","0")
+      GLPATH    ?= /usr/lib64/nvidia
+      GLLINK    ?= -L/usr/lib64/nvidia
+      DFLT_PATH ?= /usr/lib64
+    endif
+    ifeq ("$(CENTOS)","0")
+      GLPATH    ?= /usr/lib64/nvidia
+      GLLINK    ?= -L/usr/lib64/nvidia
+      DFLT_PATH ?= /usr/lib64
+    endif
+  
+  # find libGL, libGLU 
+  GLLIB  := $(shell find -L $(GLPATH) $(DFLT_PATH) -name libGL.so  -print 2>/dev/null)
+  GLULIB := $(shell find -L $(GLPATH) $(DFLT_PATH) -name libGLU.so -print 2>/dev/null)
+
+  ifeq ("$(GLLIB)","")
+      $(info >>> WARNING - libGL.so not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+  ifeq ("$(GLULIB)","")
+      $(info >>> WARNING - libGLU.so not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+
+  HEADER_SEARCH_PATH ?= $(TARGET_FS)/usr/include
+  ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+      HEADER_SEARCH_PATH += /usr/arm-linux-gnueabihf/include
+  else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-aarch64-linux)
+      HEADER_SEARCH_PATH += /usr/aarch64-linux-gnu/include
+  endif
+
+  GLHEADER  := $(shell find -L $(HEADER_SEARCH_PATH) -name gl.h -print 2>/dev/null)
+  GLUHEADER := $(shell find -L $(HEADER_SEARCH_PATH) -name glu.h -print 2>/dev/null)
+
+  ifeq ("$(GLHEADER)","")
+      $(info >>> WARNING - gl.h not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+  ifeq ("$(GLUHEADER)","")
+      $(info >>> WARNING - glu.h not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+else
+    # This would be the Mac OS X path if we had to do anything special
+endif
+
--- a/Samples/marchingCubes/marchingCubes.cpp
+++ b/Samples/marchingCubes/marchingCubes.cpp
@@ -0,0 +1,976 @@
+/* Copyright (c) 2021, 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.
+ */
+
+/*
+  Marching cubes
+
+  This sample extracts a geometric isosurface from a volume dataset using
+  the marching cubes algorithm. It uses the scan (prefix sum) function from
+  the Thrust library to perform stream compaction.  Similar techniques can
+  be used for other problems that require a variable-sized output per
+  thread.
+
+  For more information on marching cubes see:
+  http://local.wasp.uwa.edu.au/~pbourke/geometry/polygonise/
+  http://en.wikipedia.org/wiki/Marching_cubes
+
+  Volume data courtesy:
+  http://www9.informatik.uni-erlangen.de/External/vollib/
+
+  For more information on the Thrust library
+  http://code.google.com/p/thrust/
+
+  The algorithm consists of several stages:
+
+  1. Execute "classifyVoxel" kernel
+  This evaluates the volume at the corners of each voxel and computes the
+  number of vertices each voxel will generate.
+  It is executed using one thread per voxel.
+  It writes two arrays - voxelOccupied and voxelVertices to global memory.
+  voxelOccupied is a flag indicating if the voxel is non-empty.
+
+  2. Scan "voxelOccupied" array (using Thrust scan)
+  Read back the total number of occupied voxels from GPU to CPU.
+  This is the sum of the last value of the exclusive scan and the last
+  input value.
+
+  3. Execute "compactVoxels" kernel
+  This compacts the voxelOccupied array to get rid of empty voxels.
+  This allows us to run the complex "generateTriangles" kernel on only
+  the occupied voxels.
+
+  4. Scan voxelVertices array
+  This gives the start address for the vertex data for each voxel.
+  We read back the total number of vertices generated from GPU to CPU.
+
+  Note that by using a custom scan function we could combine the above two
+  scan operations above into a single operation.
+
+  5. Execute "generateTriangles" kernel
+  This runs only on the occupied voxels.
+  It looks up the field values again and generates the triangle data,
+  using the results of the scan to write the output to the correct addresses.
+  The marching cubes look-up tables are stored in 1D textures.
+
+  6. Render geometry
+  Using number of vertices from readback.
+*/
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+#define WINDOWS_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#endif
+
+// includes
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <helper_gl.h>
+
+#include <cuda_runtime.h>
+#include <cuda_gl_interop.h>
+#include <vector_types.h>
+#include <vector_functions.h>
+
+#include <helper_cuda.h>  // includes cuda.h and cuda_runtime_api.h
+#include <helper_functions.h>
+
+#include "defines.h"
+
+#if defined(__APPLE__) || defined(MACOSX)
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#include <GLUT/glut.h>
+#else
+#include <GL/freeglut.h>
+#endif
+
+extern "C" void launch_classifyVoxel(dim3 grid, dim3 threads, uint *voxelVerts,
+                                     uint *voxelOccupied, uchar *volume,
+                                     uint3 gridSize, uint3 gridSizeShift,
+                                     uint3 gridSizeMask, uint numVoxels,
+                                     float3 voxelSize, float isoValue);
+
+extern "C" void launch_compactVoxels(dim3 grid, dim3 threads,
+                                     uint *compactedVoxelArray,
+                                     uint *voxelOccupied,
+                                     uint *voxelOccupiedScan, uint numVoxels);
+
+extern "C" void launch_generateTriangles(
+    dim3 grid, dim3 threads, float4 *pos, float4 *norm,
+    uint *compactedVoxelArray, uint *numVertsScanned, uint3 gridSize,
+    uint3 gridSizeShift, uint3 gridSizeMask, float3 voxelSize, float isoValue,
+    uint activeVoxels, uint maxVerts);
+
+extern "C" void launch_generateTriangles2(
+    dim3 grid, dim3 threads, float4 *pos, float4 *norm,
+    uint *compactedVoxelArray, uint *numVertsScanned, uchar *volume,
+    uint3 gridSize, uint3 gridSizeShift, uint3 gridSizeMask, float3 voxelSize,
+    float isoValue, uint activeVoxels, uint maxVerts);
+
+extern "C" void allocateTextures(uint **d_edgeTable, uint **d_triTable,
+                                 uint **d_numVertsTable);
+extern "C" void createVolumeTexture(uchar *d_volume, size_t buffSize);
+extern "C" void destroyAllTextureObjects();
+extern "C" void ThrustScanWrapper(unsigned int *output, unsigned int *input,
+                                  unsigned int numElements);
+
+// constants
+const unsigned int window_width = 512;
+const unsigned int window_height = 512;
+
+const char *volumeFilename = "Bucky.raw";
+
+uint3 gridSizeLog2 = make_uint3(5, 5, 5);
+uint3 gridSizeShift;
+uint3 gridSize;
+uint3 gridSizeMask;
+
+float3 voxelSize;
+uint numVoxels = 0;
+uint maxVerts = 0;
+uint activeVoxels = 0;
+uint totalVerts = 0;
+
+float isoValue = 0.2f;
+float dIsoValue = 0.005f;
+
+// device data
+GLuint posVbo, normalVbo;
+GLint gl_Shader;
+struct cudaGraphicsResource *cuda_posvbo_resource,
+    *cuda_normalvbo_resource;  // handles OpenGL-CUDA exchange
+
+float4 *d_pos = 0, *d_normal = 0;
+
+uchar *d_volume = 0;
+uint *d_voxelVerts = 0;
+uint *d_voxelVertsScan = 0;
+uint *d_voxelOccupied = 0;
+uint *d_voxelOccupiedScan = 0;
+uint *d_compVoxelArray;
+
+// tables
+uint *d_numVertsTable = 0;
+uint *d_edgeTable = 0;
+uint *d_triTable = 0;
+
+// mouse controls
+int mouse_old_x, mouse_old_y;
+int mouse_buttons = 0;
+float3 rotate = make_float3(0.0, 0.0, 0.0);
+float3 translate = make_float3(0.0, 0.0, -3.0);
+
+// toggles
+bool wireframe = false;
+bool animate = true;
+bool lighting = true;
+bool render = true;
+bool compute = true;
+
+#define MAX_EPSILON_ERROR 5.0f
+#define REFRESH_DELAY 10  // ms
+
+// Define the files that are to be save and the reference images for validation
+const char *sOriginal[] = {"march_cubes.ppm", NULL};
+
+const char *sReference[] = {"ref_march_cubes.ppm", NULL};
+
+StopWatchInterface *timer = 0;
+
+// Auto-Verification Code
+const int frameCheckNumber = 4;
+int fpsCount = 0;  // FPS count for averaging
+int fpsLimit = 1;  // FPS limit for sampling
+int g_Index = 0;
+unsigned int frameCount = 0;
+bool g_bValidate = false;
+
+int *pArgc = NULL;
+char **pArgv = NULL;
+
+// forward declarations
+void runGraphicsTest(int argc, char **argv);
+void runAutoTest(int argc, char **argv);
+void initMC(int argc, char **argv);
+void computeIsosurface();
+void dumpFile(void *dData, int data_bytes, const char *file_name);
+
+template <class T>
+void dumpBuffer(T *d_buffer, int nelements, int size_element);
+
+void cleanup();
+
+bool initGL(int *argc, char **argv);
+void createVBO(GLuint *vbo, unsigned int size);
+void deleteVBO(GLuint *vbo, struct cudaGraphicsResource **cuda_resource);
+
+void display();
+void keyboard(unsigned char key, int x, int y);
+void mouse(int button, int state, int x, int y);
+void motion(int x, int y);
+void idle();
+void reshape(int w, int h);
+
+void mainMenu(int i);
+
+#define EPSILON 5.0f
+#define THRESHOLD 0.30f
+
+void animation() {
+  if (animate) {
+    isoValue += dIsoValue;
+
+    if (isoValue < 0.1f) {
+      isoValue = 0.1f;
+      dIsoValue *= -1.0f;
+    } else if (isoValue > 0.9f) {
+      isoValue = 0.9f;
+      dIsoValue *= -1.0f;
+    }
+  }
+}
+
+void timerEvent(int value) {
+  animation();
+  glutPostRedisplay();
+  glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
+}
+
+void computeFPS() {
+  frameCount++;
+  fpsCount++;
+
+  if (fpsCount == fpsLimit) {
+    char fps[256];
+    float ifps = 1.f / (sdkGetAverageTimerValue(&timer) / 1000.f);
+    sprintf(fps, "CUDA Marching Cubes: %3.1f fps", ifps);
+
+    glutSetWindowTitle(fps);
+    fpsCount = 0;
+
+    fpsLimit = ftoi(MAX(1.f, ifps));
+    sdkResetTimer(&timer);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Load raw data from disk
+////////////////////////////////////////////////////////////////////////////////
+uchar *loadRawFile(char *filename, int size) {
+  FILE *fp = fopen(filename, "rb");
+
+  if (!fp) {
+    fprintf(stderr, "Error opening file '%s'\n", filename);
+    return 0;
+  }
+
+  uchar *data = (uchar *)malloc(size);
+  size_t read = fread(data, 1, size, fp);
+  fclose(fp);
+
+  printf("Read '%s', %d bytes\n", filename, (int)read);
+
+  return data;
+}
+
+void dumpFile(void *dData, int data_bytes, const char *file_name) {
+  void *hData = malloc(data_bytes);
+  checkCudaErrors(cudaMemcpy(hData, dData, data_bytes, cudaMemcpyDeviceToHost));
+  sdkDumpBin(hData, data_bytes, file_name);
+  free(hData);
+}
+
+template <class T>
+void dumpBuffer(T *d_buffer, int nelements, int size_element) {
+  uint bytes = nelements * size_element;
+  T *h_buffer = (T *)malloc(bytes);
+  checkCudaErrors(
+      cudaMemcpy(h_buffer, d_buffer, bytes, cudaMemcpyDeviceToHost));
+
+  for (int i = 0; i < nelements; i++) {
+    printf("%d: %u\n", i, h_buffer[i]);
+  }
+
+  printf("\n");
+  free(h_buffer);
+}
+
+void runAutoTest(int argc, char **argv) {
+  findCudaDevice(argc, (const char **)argv);
+
+  // Initialize CUDA buffers for Marching Cubes
+  initMC(argc, argv);
+
+  computeIsosurface();
+
+  char *ref_file = NULL;
+  getCmdLineArgumentString(argc, (const char **)argv, "file", &ref_file);
+
+  enum DUMP_TYPE { DUMP_POS = 0, DUMP_NORMAL, DUMP_VOXEL };
+  int dump_option = getCmdLineArgumentInt(argc, (const char **)argv, "dump");
+
+  bool bTestResult = true;
+
+  switch (dump_option) {
+    case DUMP_POS:
+      dumpFile((void *)d_pos, sizeof(float4) * maxVerts,
+               "marchCube_posArray.bin");
+      bTestResult = sdkCompareBin2BinFloat(
+          "marchCube_posArray.bin", "posArray.bin",
+          maxVerts * sizeof(float) * 4, EPSILON, THRESHOLD, argv[0]);
+      break;
+
+    case DUMP_NORMAL:
+      dumpFile((void *)d_normal, sizeof(float4) * maxVerts,
+               "marchCube_normalArray.bin");
+      bTestResult = sdkCompareBin2BinFloat(
+          "marchCube_normalArray.bin", "normalArray.bin",
+          maxVerts * sizeof(float) * 4, EPSILON, THRESHOLD, argv[0]);
+      break;
+
+    case DUMP_VOXEL:
+      dumpFile((void *)d_compVoxelArray, sizeof(uint) * numVoxels,
+               "marchCube_compVoxelArray.bin");
+      bTestResult = sdkCompareBin2BinFloat(
+          "marchCube_compVoxelArray.bin", "compVoxelArray.bin",
+          numVoxels * sizeof(uint), EPSILON, THRESHOLD, argv[0]);
+      break;
+
+    default:
+      printf("Invalid validation flag!\n");
+      printf("-dump=0 <check position>\n");
+      printf("-dump=1 <check normal>\n");
+      printf("-dump=2 <check voxel>\n");
+      exit(EXIT_SUCCESS);
+  }
+
+  exit(bTestResult ? EXIT_SUCCESS : EXIT_FAILURE);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Program main
+////////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv) {
+  pArgc = &argc;
+  pArgv = argv;
+
+#if defined(__linux__)
+  setenv("DISPLAY", ":0", 0);
+#endif
+
+  printf("[%s] - Starting...\n", argv[0]);
+
+  if (checkCmdLineFlag(argc, (const char **)argv, "file") &&
+      checkCmdLineFlag(argc, (const char **)argv, "dump")) {
+    animate = false;
+    fpsLimit = frameCheckNumber;
+    g_bValidate = true;
+    runAutoTest(argc, argv);
+  } else {
+    runGraphicsTest(argc, argv);
+  }
+
+  exit(EXIT_SUCCESS);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// initialize marching cubes
+////////////////////////////////////////////////////////////////////////////////
+void initMC(int argc, char **argv) {
+  // parse command line arguments
+  int n;
+
+  if (checkCmdLineFlag(argc, (const char **)argv, "grid")) {
+    n = getCmdLineArgumentInt(argc, (const char **)argv, "grid");
+    gridSizeLog2.x = gridSizeLog2.y = gridSizeLog2.z = n;
+  }
+
+  if (checkCmdLineFlag(argc, (const char **)argv, "gridx")) {
+    n = getCmdLineArgumentInt(argc, (const char **)argv, "gridx");
+    gridSizeLog2.x = n;
+  }
+
+  if (checkCmdLineFlag(argc, (const char **)argv, "gridx")) {
+    n = getCmdLineArgumentInt(argc, (const char **)argv, "gridx");
+    gridSizeLog2.y = n;
+  }
+
+  if (checkCmdLineFlag(argc, (const char **)argv, "gridz")) {
+    n = getCmdLineArgumentInt(argc, (const char **)argv, "gridz");
+    gridSizeLog2.z = n;
+  }
+
+  char *filename;
+
+  if (getCmdLineArgumentString(argc, (const char **)argv, "file", &filename)) {
+    volumeFilename = filename;
+  }
+
+  gridSize =
+      make_uint3(1 << gridSizeLog2.x, 1 << gridSizeLog2.y, 1 << gridSizeLog2.z);
+  gridSizeMask = make_uint3(gridSize.x - 1, gridSize.y - 1, gridSize.z - 1);
+  gridSizeShift =
+      make_uint3(0, gridSizeLog2.x, gridSizeLog2.x + gridSizeLog2.y);
+
+  numVoxels = gridSize.x * gridSize.y * gridSize.z;
+  voxelSize =
+      make_float3(2.0f / gridSize.x, 2.0f / gridSize.y, 2.0f / gridSize.z);
+  maxVerts = gridSize.x * gridSize.y * 100;
+
+  printf("grid: %d x %d x %d = %d voxels\n", gridSize.x, gridSize.y, gridSize.z,
+         numVoxels);
+  printf("max verts = %d\n", maxVerts);
+
+#if SAMPLE_VOLUME
+  // load volume data
+  char *path = sdkFindFilePath(volumeFilename, argv[0]);
+
+  if (path == NULL) {
+    fprintf(stderr, "Error finding file '%s'\n", volumeFilename);
+
+    exit(EXIT_FAILURE);
+  }
+
+  int size = gridSize.x * gridSize.y * gridSize.z * sizeof(uchar);
+  uchar *volume = loadRawFile(path, size);
+  checkCudaErrors(cudaMalloc((void **)&d_volume, size));
+  checkCudaErrors(cudaMemcpy(d_volume, volume, size, cudaMemcpyHostToDevice));
+  free(volume);
+
+  createVolumeTexture(d_volume, size);
+#endif
+
+  if (g_bValidate) {
+    cudaMalloc((void **)&(d_pos), maxVerts * sizeof(float) * 4);
+    cudaMalloc((void **)&(d_normal), maxVerts * sizeof(float) * 4);
+  } else {
+    // create VBOs
+    createVBO(&posVbo, maxVerts * sizeof(float) * 4);
+    // DEPRECATED: checkCudaErrors( cudaGLRegisterBufferObject(posVbo) );
+    checkCudaErrors(cudaGraphicsGLRegisterBuffer(
+        &cuda_posvbo_resource, posVbo, cudaGraphicsMapFlagsWriteDiscard));
+
+    createVBO(&normalVbo, maxVerts * sizeof(float) * 4);
+    // DEPRECATED: checkCudaErrors(cudaGLRegisterBufferObject(normalVbo));
+    checkCudaErrors(cudaGraphicsGLRegisterBuffer(
+        &cuda_normalvbo_resource, normalVbo, cudaGraphicsMapFlagsWriteDiscard));
+  }
+
+  // allocate textures
+  allocateTextures(&d_edgeTable, &d_triTable, &d_numVertsTable);
+
+  // allocate device memory
+  unsigned int memSize = sizeof(uint) * numVoxels;
+  checkCudaErrors(cudaMalloc((void **)&d_voxelVerts, memSize));
+  checkCudaErrors(cudaMalloc((void **)&d_voxelVertsScan, memSize));
+  checkCudaErrors(cudaMalloc((void **)&d_voxelOccupied, memSize));
+  checkCudaErrors(cudaMalloc((void **)&d_voxelOccupiedScan, memSize));
+  checkCudaErrors(cudaMalloc((void **)&d_compVoxelArray, memSize));
+}
+
+void cleanup() {
+  if (g_bValidate) {
+    cudaFree(d_pos);
+    cudaFree(d_normal);
+  } else {
+    sdkDeleteTimer(&timer);
+
+    deleteVBO(&posVbo, &cuda_posvbo_resource);
+    deleteVBO(&normalVbo, &cuda_normalvbo_resource);
+  }
+  destroyAllTextureObjects();
+  checkCudaErrors(cudaFree(d_edgeTable));
+  checkCudaErrors(cudaFree(d_triTable));
+  checkCudaErrors(cudaFree(d_numVertsTable));
+
+  checkCudaErrors(cudaFree(d_voxelVerts));
+  checkCudaErrors(cudaFree(d_voxelVertsScan));
+  checkCudaErrors(cudaFree(d_voxelOccupied));
+  checkCudaErrors(cudaFree(d_voxelOccupiedScan));
+  checkCudaErrors(cudaFree(d_compVoxelArray));
+
+  if (d_volume) {
+    checkCudaErrors(cudaFree(d_volume));
+  }
+}
+
+void initMenus() {
+  glutCreateMenu(mainMenu);
+  glutAddMenuEntry("Toggle animation [ ]", ' ');
+  glutAddMenuEntry("Increment isovalue [+]", '+');
+  glutAddMenuEntry("Decrement isovalue [-]", '-');
+  glutAddMenuEntry("Toggle computation [c]", 'c');
+  glutAddMenuEntry("Toggle rendering [r]", 'r');
+  glutAddMenuEntry("Toggle lighting [l]", 'l');
+  glutAddMenuEntry("Toggle wireframe [w]", 'w');
+  glutAddMenuEntry("Quit (esc)", '\033');
+  glutAttachMenu(GLUT_RIGHT_BUTTON);
+}
+
+void runGraphicsTest(int argc, char **argv) {
+  printf("MarchingCubes\n");
+
+  if (checkCmdLineFlag(argc, (const char **)argv, "device")) {
+    printf("[%s]\n", argv[0]);
+    printf("   Does not explicitly support -device=n in OpenGL mode\n");
+    printf("   To use -device=n, the sample must be running w/o OpenGL\n\n");
+    printf(" > %s -device=n -file=<reference> -dump=<0/1/2>\n", argv[0]);
+    exit(EXIT_SUCCESS);
+  }
+
+  // First initialize OpenGL context, so we can properly set the GL for CUDA.
+  // This is necessary in order to achieve optimal performance with OpenGL/CUDA
+  // interop.
+  if (false == initGL(&argc, argv)) {
+    return;
+  }
+
+  findCudaDevice(argc, (const char **)argv);
+
+  // register callbacks
+  glutDisplayFunc(display);
+  glutKeyboardFunc(keyboard);
+  glutMouseFunc(mouse);
+  glutMotionFunc(motion);
+  glutReshapeFunc(reshape);
+  glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
+  initMenus();
+
+  // Initialize CUDA buffers for Marching Cubes
+  initMC(argc, argv);
+
+  sdkCreateTimer(&timer);
+
+  // start rendering mainloop
+  glutMainLoop();
+}
+
+#define DEBUG_BUFFERS 0
+
+////////////////////////////////////////////////////////////////////////////////
+//! Run the Cuda part of the computation
+////////////////////////////////////////////////////////////////////////////////
+void computeIsosurface() {
+  int threads = 128;
+  dim3 grid(numVoxels / threads, 1, 1);
+
+  // get around maximum grid size of 65535 in each dimension
+  if (grid.x > 65535) {
+    grid.y = grid.x / 32768;
+    grid.x = 32768;
+  }
+
+  // calculate number of vertices need per voxel
+  launch_classifyVoxel(grid, threads, d_voxelVerts, d_voxelOccupied, d_volume,
+                       gridSize, gridSizeShift, gridSizeMask, numVoxels,
+                       voxelSize, isoValue);
+#if DEBUG_BUFFERS
+  printf("voxelVerts:\n");
+  dumpBuffer(d_voxelVerts, numVoxels, sizeof(uint));
+#endif
+
+#if SKIP_EMPTY_VOXELS
+  // scan voxel occupied array
+  ThrustScanWrapper(d_voxelOccupiedScan, d_voxelOccupied, numVoxels);
+
+#if DEBUG_BUFFERS
+  printf("voxelOccupiedScan:\n");
+  dumpBuffer(d_voxelOccupiedScan, numVoxels, sizeof(uint));
+#endif
+
+  // read back values to calculate total number of non-empty voxels
+  // since we are using an exclusive scan, the total is the last value of
+  // the scan result plus the last value in the input array
+  {
+    uint lastElement, lastScanElement;
+    checkCudaErrors(cudaMemcpy((void *)&lastElement,
+                               (void *)(d_voxelOccupied + numVoxels - 1),
+                               sizeof(uint), cudaMemcpyDeviceToHost));
+    checkCudaErrors(cudaMemcpy((void *)&lastScanElement,
+                               (void *)(d_voxelOccupiedScan + numVoxels - 1),
+                               sizeof(uint), cudaMemcpyDeviceToHost));
+    activeVoxels = lastElement + lastScanElement;
+  }
+
+  if (activeVoxels == 0) {
+    // return if there are no full voxels
+    totalVerts = 0;
+    return;
+  }
+
+  // compact voxel index array
+  launch_compactVoxels(grid, threads, d_compVoxelArray, d_voxelOccupied,
+                       d_voxelOccupiedScan, numVoxels);
+  getLastCudaError("compactVoxels failed");
+
+#endif  // SKIP_EMPTY_VOXELS
+
+  // scan voxel vertex count array
+  ThrustScanWrapper(d_voxelVertsScan, d_voxelVerts, numVoxels);
+
+#if DEBUG_BUFFERS
+  printf("voxelVertsScan:\n");
+  dumpBuffer(d_voxelVertsScan, numVoxels, sizeof(uint));
+#endif
+
+  // readback total number of vertices
+  {
+    uint lastElement, lastScanElement;
+    checkCudaErrors(cudaMemcpy((void *)&lastElement,
+                               (void *)(d_voxelVerts + numVoxels - 1),
+                               sizeof(uint), cudaMemcpyDeviceToHost));
+    checkCudaErrors(cudaMemcpy((void *)&lastScanElement,
+                               (void *)(d_voxelVertsScan + numVoxels - 1),
+                               sizeof(uint), cudaMemcpyDeviceToHost));
+    totalVerts = lastElement + lastScanElement;
+  }
+
+  // generate triangles, writing to vertex buffers
+  if (!g_bValidate) {
+    size_t num_bytes;
+    // DEPRECATED: checkCudaErrors(cudaGLMapBufferObject((void**)&d_pos,
+    // posVbo));
+    checkCudaErrors(cudaGraphicsMapResources(1, &cuda_posvbo_resource, 0));
+    checkCudaErrors(cudaGraphicsResourceGetMappedPointer(
+        (void **)&d_pos, &num_bytes, cuda_posvbo_resource));
+
+    // DEPRECATED: checkCudaErrors(cudaGLMapBufferObject((void**)&d_normal,
+    // normalVbo));
+    checkCudaErrors(cudaGraphicsMapResources(1, &cuda_normalvbo_resource, 0));
+    checkCudaErrors(cudaGraphicsResourceGetMappedPointer(
+        (void **)&d_normal, &num_bytes, cuda_normalvbo_resource));
+  }
+
+#if SKIP_EMPTY_VOXELS
+  dim3 grid2((int)ceil(activeVoxels / (float)NTHREADS), 1, 1);
+#else
+  dim3 grid2((int)ceil(numVoxels / (float)NTHREADS), 1, 1);
+#endif
+
+  while (grid2.x > 65535) {
+    grid2.x /= 2;
+    grid2.y *= 2;
+  }
+
+#if SAMPLE_VOLUME
+  launch_generateTriangles2(grid2, NTHREADS, d_pos, d_normal, d_compVoxelArray,
+                            d_voxelVertsScan, d_volume, gridSize, gridSizeShift,
+                            gridSizeMask, voxelSize, isoValue, activeVoxels,
+                            maxVerts);
+#else
+  launch_generateTriangles(grid2, NTHREADS, d_pos, d_normal, d_compVoxelArray,
+                           d_voxelVertsScan, gridSize, gridSizeShift,
+                           gridSizeMask, voxelSize, isoValue, activeVoxels,
+                           maxVerts);
+#endif
+
+  if (!g_bValidate) {
+    // DEPRECATED:      checkCudaErrors(cudaGLUnmapBufferObject(normalVbo));
+    checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_normalvbo_resource, 0));
+    // DEPRECATED:      checkCudaErrors(cudaGLUnmapBufferObject(posVbo));
+    checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_posvbo_resource, 0));
+  }
+}
+
+// shader for displaying floating-point texture
+static const char *shader_code =
+    "!!ARBfp1.0\n"
+    "TEX result.color, fragment.texcoord, texture[0], 2D; \n"
+    "END";
+
+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) {
+    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);
+    return 0;
+  }
+
+  return program_id;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! Initialize OpenGL
+////////////////////////////////////////////////////////////////////////////////
+bool initGL(int *argc, char **argv) {
+  // Create GL context
+  glutInit(argc, argv);
+  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
+  glutInitWindowSize(window_width, window_height);
+  glutCreateWindow("CUDA Marching Cubes");
+
+  if (!isGLVersionSupported(2, 0)) {
+    fprintf(stderr, "ERROR: Support for necessary OpenGL extensions missing.");
+    fflush(stderr);
+    return false;
+  }
+
+  // default initialization
+  glClearColor(0.1f, 0.2f, 0.3f, 1.0f);
+  glEnable(GL_DEPTH_TEST);
+
+  // good old-fashioned fixed function lighting
+  float black[] = {0.0f, 0.0f, 0.0f, 1.0f};
+  float white[] = {1.0f, 1.0f, 1.0f, 1.0f};
+  float ambient[] = {0.1f, 0.1f, 0.1f, 1.0f};
+  float diffuse[] = {0.9f, 0.9f, 0.9f, 1.0f};
+  float lightPos[] = {0.0f, 0.0f, 1.0f, 0.0f};
+
+  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
+  glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);
+  glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, black);
+
+  glLightfv(GL_LIGHT0, GL_AMBIENT, white);
+  glLightfv(GL_LIGHT0, GL_DIFFUSE, white);
+  glLightfv(GL_LIGHT0, GL_SPECULAR, white);
+  glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
+
+  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, black);
+
+  glEnable(GL_LIGHT0);
+  glEnable(GL_NORMALIZE);
+
+  // load shader program
+  gl_Shader = compileASMShader(GL_FRAGMENT_PROGRAM_ARB, shader_code);
+
+  glutReportErrors();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! Create VBO
+////////////////////////////////////////////////////////////////////////////////
+void createVBO(GLuint *vbo, unsigned int size) {
+  // create buffer object
+  glGenBuffers(1, vbo);
+  glBindBuffer(GL_ARRAY_BUFFER, *vbo);
+
+  // initialize buffer object
+  glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+  glutReportErrors();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! Delete VBO
+////////////////////////////////////////////////////////////////////////////////
+void deleteVBO(GLuint *vbo, struct cudaGraphicsResource **cuda_resource) {
+  glBindBuffer(1, *vbo);
+  glDeleteBuffers(1, vbo);
+  // DEPRECATED: checkCudaErrors(cudaGLUnregisterBufferObject(*vbo));
+  cudaGraphicsUnregisterResource(*cuda_resource);
+
+  *vbo = 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Render isosurface geometry from the vertex buffers
+////////////////////////////////////////////////////////////////////////////////
+void renderIsosurface() {
+  glBindBuffer(GL_ARRAY_BUFFER, posVbo);
+  glVertexPointer(4, GL_FLOAT, 0, 0);
+  glEnableClientState(GL_VERTEX_ARRAY);
+
+  glBindBuffer(GL_ARRAY_BUFFER, normalVbo);
+  glNormalPointer(GL_FLOAT, sizeof(float) * 4, 0);
+  glEnableClientState(GL_NORMAL_ARRAY);
+
+  glColor3f(1.0, 0.0, 0.0);
+  glDrawArrays(GL_TRIANGLES, 0, totalVerts);
+  glDisableClientState(GL_VERTEX_ARRAY);
+  glDisableClientState(GL_NORMAL_ARRAY);
+
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! Display callback
+////////////////////////////////////////////////////////////////////////////////
+void display() {
+  sdkStartTimer(&timer);
+
+  // run CUDA kernel to generate geometry
+  if (compute) {
+    computeIsosurface();
+  }
+
+  // Common display code path
+  {
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    // set view matrix
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glTranslatef(translate.x, translate.y, translate.z);
+    glRotatef(rotate.x, 1.0, 0.0, 0.0);
+    glRotatef(rotate.y, 0.0, 1.0, 0.0);
+
+    glPolygonMode(GL_FRONT_AND_BACK, wireframe ? GL_LINE : GL_FILL);
+
+    if (lighting) {
+      glEnable(GL_LIGHTING);
+    }
+
+    // render
+    if (render) {
+      glPushMatrix();
+      glRotatef(180.0, 0.0, 1.0, 0.0);
+      glRotatef(90.0, 1.0, 0.0, 0.0);
+      renderIsosurface();
+      glPopMatrix();
+    }
+
+    glDisable(GL_LIGHTING);
+  }
+
+  glutSwapBuffers();
+  glutReportErrors();
+
+  sdkStopTimer(&timer);
+
+  computeFPS();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! Keyboard events handler
+////////////////////////////////////////////////////////////////////////////////
+void keyboard(unsigned char key, int /*x*/, int /*y*/) {
+  switch (key) {
+    case (27):
+      cleanup();
+      exit(EXIT_SUCCESS);
+
+    case '=':
+      isoValue += 0.01f;
+      break;
+
+    case '-':
+      isoValue -= 0.01f;
+      break;
+
+    case '+':
+      isoValue += 0.1f;
+      break;
+
+    case '_':
+      isoValue -= 0.1f;
+      break;
+
+    case 'w':
+      wireframe = !wireframe;
+      break;
+
+    case ' ':
+      animate = !animate;
+      break;
+
+    case 'l':
+      lighting = !lighting;
+      break;
+
+    case 'r':
+      render = !render;
+      break;
+
+    case 'c':
+      compute = !compute;
+      break;
+  }
+
+  printf("isoValue = %f\n", isoValue);
+  printf("voxels = %d\n", activeVoxels);
+  printf("verts = %d\n", totalVerts);
+  printf("occupancy: %d / %d = %.2f%%\n", activeVoxels, numVoxels,
+         activeVoxels * 100.0f / (float)numVoxels);
+
+  if (!compute) {
+    computeIsosurface();
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! Mouse event handlers
+////////////////////////////////////////////////////////////////////////////////
+void mouse(int button, int state, int x, int y) {
+  if (state == GLUT_DOWN) {
+    mouse_buttons |= 1 << button;
+  } else if (state == GLUT_UP) {
+    mouse_buttons = 0;
+  }
+
+  mouse_old_x = x;
+  mouse_old_y = y;
+}
+
+void motion(int x, int y) {
+  float dx = (float)(x - mouse_old_x);
+  float dy = (float)(y - mouse_old_y);
+
+  if (mouse_buttons == 1) {
+    rotate.x += dy * 0.2f;
+    rotate.y += dx * 0.2f;
+  } else if (mouse_buttons == 2) {
+    translate.x += dx * 0.01f;
+    translate.y -= dy * 0.01f;
+  } else if (mouse_buttons == 3) {
+    translate.z += dy * 0.01f;
+  }
+
+  mouse_old_x = x;
+  mouse_old_y = y;
+  glutPostRedisplay();
+}
+
+void idle() {
+  animation();
+  glutPostRedisplay();
+}
+
+void reshape(int w, int h) {
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  gluPerspective(60.0, (float)w / (float)h, 0.1, 10.0);
+
+  glMatrixMode(GL_MODELVIEW);
+  glViewport(0, 0, w, h);
+}
+
+void mainMenu(int i) { keyboard((unsigned char)i, 0, 0); }
--- a/Samples/marchingCubes/marchingCubes_kernel.cu
+++ b/Samples/marchingCubes/marchingCubes_kernel.cu
@@ -0,0 +1,667 @@
+/* Copyright (c) 2021, 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 _MARCHING_CUBES_KERNEL_CU_
+#define _MARCHING_CUBES_KERNEL_CU_
+
+#include <stdio.h>
+#include <string.h>
+#include <helper_cuda.h>  // includes for helper CUDA functions
+#include <helper_math.h>
+#include <cuda_runtime_api.h>
+#include <thrust/device_vector.h>
+#include <thrust/scan.h>
+
+#include "defines.h"
+#include "tables.h"
+
+// textures containing look-up tables
+cudaTextureObject_t triTex;
+cudaTextureObject_t numVertsTex;
+
+// volume data
+cudaTextureObject_t volumeTex;
+
+extern "C" void allocateTextures(uint **d_edgeTable, uint **d_triTable,
+                                 uint **d_numVertsTable) {
+  checkCudaErrors(cudaMalloc((void **)d_edgeTable, 256 * sizeof(uint)));
+  checkCudaErrors(cudaMemcpy((void *)*d_edgeTable, (void *)edgeTable,
+                             256 * sizeof(uint), cudaMemcpyHostToDevice));
+  cudaChannelFormatDesc channelDesc =
+      cudaCreateChannelDesc(32, 0, 0, 0, cudaChannelFormatKindUnsigned);
+
+  checkCudaErrors(cudaMalloc((void **)d_triTable, 256 * 16 * sizeof(uint)));
+  checkCudaErrors(cudaMemcpy((void *)*d_triTable, (void *)triTable,
+                             256 * 16 * sizeof(uint), cudaMemcpyHostToDevice));
+
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeLinear;
+  texRes.res.linear.devPtr = *d_triTable;
+  texRes.res.linear.sizeInBytes = 256 * 16 * sizeof(uint);
+  texRes.res.linear.desc = channelDesc;
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModePoint;
+  texDescr.addressMode[0] = cudaAddressModeClamp;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(cudaCreateTextureObject(&triTex, &texRes, &texDescr, NULL));
+
+  checkCudaErrors(cudaMalloc((void **)d_numVertsTable, 256 * sizeof(uint)));
+  checkCudaErrors(cudaMemcpy((void *)*d_numVertsTable, (void *)numVertsTable,
+                             256 * sizeof(uint), cudaMemcpyHostToDevice));
+
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeLinear;
+  texRes.res.linear.devPtr = *d_numVertsTable;
+  texRes.res.linear.sizeInBytes = 256 * sizeof(uint);
+  texRes.res.linear.desc = channelDesc;
+
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModePoint;
+  texDescr.addressMode[0] = cudaAddressModeClamp;
+  texDescr.readMode = cudaReadModeElementType;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&numVertsTex, &texRes, &texDescr, NULL));
+}
+
+extern "C" void createVolumeTexture(uchar *d_volume, size_t buffSize) {
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypeLinear;
+  texRes.res.linear.devPtr = d_volume;
+  texRes.res.linear.sizeInBytes = buffSize;
+  texRes.res.linear.desc =
+      cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsigned);
+
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModePoint;
+  texDescr.addressMode[0] = cudaAddressModeClamp;
+  texDescr.readMode = cudaReadModeNormalizedFloat;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&volumeTex, &texRes, &texDescr, NULL));
+}
+
+extern "C" void destroyAllTextureObjects() {
+  checkCudaErrors(cudaDestroyTextureObject(triTex));
+  checkCudaErrors(cudaDestroyTextureObject(numVertsTex));
+  checkCudaErrors(cudaDestroyTextureObject(volumeTex));
+}
+
+// an interesting field function
+__device__ float tangle(float x, float y, float z) {
+  x *= 3.0f;
+  y *= 3.0f;
+  z *= 3.0f;
+  return (x * x * x * x - 5.0f * x * x + y * y * y * y - 5.0f * y * y +
+          z * z * z * z - 5.0f * z * z + 11.8f) * 0.2f + 0.5f;
+}
+
+// evaluate field function at point
+__device__ float fieldFunc(float3 p) { return tangle(p.x, p.y, p.z); }
+
+// evaluate field function at a point
+// returns value and gradient in float4
+__device__ float4 fieldFunc4(float3 p) {
+  float v = tangle(p.x, p.y, p.z);
+  const float d = 0.001f;
+  float dx = tangle(p.x + d, p.y, p.z) - v;
+  float dy = tangle(p.x, p.y + d, p.z) - v;
+  float dz = tangle(p.x, p.y, p.z + d) - v;
+  return make_float4(dx, dy, dz, v);
+}
+
+// sample volume data set at a point
+__device__ float sampleVolume(cudaTextureObject_t volumeTex, uchar *data,
+                              uint3 p, uint3 gridSize) {
+  p.x = min(p.x, gridSize.x - 1);
+  p.y = min(p.y, gridSize.y - 1);
+  p.z = min(p.z, gridSize.z - 1);
+  uint i = (p.z * gridSize.x * gridSize.y) + (p.y * gridSize.x) + p.x;
+  //    return (float) data[i] / 255.0f;
+  return tex1Dfetch<float>(volumeTex, i);
+}
+
+// compute position in 3d grid from 1d index
+// only works for power of 2 sizes
+__device__ uint3 calcGridPos(uint i, uint3 gridSizeShift, uint3 gridSizeMask) {
+  uint3 gridPos;
+  gridPos.x = i & gridSizeMask.x;
+  gridPos.y = (i >> gridSizeShift.y) & gridSizeMask.y;
+  gridPos.z = (i >> gridSizeShift.z) & gridSizeMask.z;
+  return gridPos;
+}
+
+// classify voxel based on number of vertices it will generate
+// one thread per voxel
+__global__ void classifyVoxel(uint *voxelVerts, uint *voxelOccupied,
+                              uchar *volume, uint3 gridSize,
+                              uint3 gridSizeShift, uint3 gridSizeMask,
+                              uint numVoxels, float3 voxelSize, float isoValue,
+                              cudaTextureObject_t numVertsTex,
+                              cudaTextureObject_t volumeTex) {
+  uint blockId = __mul24(blockIdx.y, gridDim.x) + blockIdx.x;
+  uint i = __mul24(blockId, blockDim.x) + threadIdx.x;
+
+  uint3 gridPos = calcGridPos(i, gridSizeShift, gridSizeMask);
+
+// read field values at neighbouring grid vertices
+#if SAMPLE_VOLUME
+  float field[8];
+  field[0] = sampleVolume(volumeTex, volume, gridPos, gridSize);
+  field[1] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(1, 0, 0), gridSize);
+  field[2] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(1, 1, 0), gridSize);
+  field[3] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(0, 1, 0), gridSize);
+  field[4] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(0, 0, 1), gridSize);
+  field[5] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(1, 0, 1), gridSize);
+  field[6] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(1, 1, 1), gridSize);
+  field[7] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(0, 1, 1), gridSize);
+#else
+  float3 p;
+  p.x = -1.0f + (gridPos.x * voxelSize.x);
+  p.y = -1.0f + (gridPos.y * voxelSize.y);
+  p.z = -1.0f + (gridPos.z * voxelSize.z);
+
+  float field[8];
+  field[0] = fieldFunc(p);
+  field[1] = fieldFunc(p + make_float3(voxelSize.x, 0, 0));
+  field[2] = fieldFunc(p + make_float3(voxelSize.x, voxelSize.y, 0));
+  field[3] = fieldFunc(p + make_float3(0, voxelSize.y, 0));
+  field[4] = fieldFunc(p + make_float3(0, 0, voxelSize.z));
+  field[5] = fieldFunc(p + make_float3(voxelSize.x, 0, voxelSize.z));
+  field[6] = fieldFunc(p + make_float3(voxelSize.x, voxelSize.y, voxelSize.z));
+  field[7] = fieldFunc(p + make_float3(0, voxelSize.y, voxelSize.z));
+#endif
+
+  // calculate flag indicating if each vertex is inside or outside isosurface
+  uint cubeindex;
+  cubeindex = uint(field[0] < isoValue);
+  cubeindex += uint(field[1] < isoValue) * 2;
+  cubeindex += uint(field[2] < isoValue) * 4;
+  cubeindex += uint(field[3] < isoValue) * 8;
+  cubeindex += uint(field[4] < isoValue) * 16;
+  cubeindex += uint(field[5] < isoValue) * 32;
+  cubeindex += uint(field[6] < isoValue) * 64;
+  cubeindex += uint(field[7] < isoValue) * 128;
+
+  // read number of vertices from texture
+  uint numVerts = tex1Dfetch<uint>(numVertsTex, cubeindex);
+
+  if (i < numVoxels) {
+    voxelVerts[i] = numVerts;
+    voxelOccupied[i] = (numVerts > 0);
+  }
+}
+
+extern "C" void launch_classifyVoxel(dim3 grid, dim3 threads, uint *voxelVerts,
+                                     uint *voxelOccupied, uchar *volume,
+                                     uint3 gridSize, uint3 gridSizeShift,
+                                     uint3 gridSizeMask, uint numVoxels,
+                                     float3 voxelSize, float isoValue) {
+  // calculate number of vertices need per voxel
+  classifyVoxel<<<grid, threads>>>(voxelVerts, voxelOccupied, volume, gridSize,
+                                   gridSizeShift, gridSizeMask, numVoxels,
+                                   voxelSize, isoValue, numVertsTex, volumeTex);
+  getLastCudaError("classifyVoxel failed");
+}
+
+// compact voxel array
+__global__ void compactVoxels(uint *compactedVoxelArray, uint *voxelOccupied,
+                              uint *voxelOccupiedScan, uint numVoxels) {
+  uint blockId = __mul24(blockIdx.y, gridDim.x) + blockIdx.x;
+  uint i = __mul24(blockId, blockDim.x) + threadIdx.x;
+
+  if (voxelOccupied[i] && (i < numVoxels)) {
+    compactedVoxelArray[voxelOccupiedScan[i]] = i;
+  }
+}
+
+extern "C" void launch_compactVoxels(dim3 grid, dim3 threads,
+                                     uint *compactedVoxelArray,
+                                     uint *voxelOccupied,
+                                     uint *voxelOccupiedScan, uint numVoxels) {
+  compactVoxels<<<grid, threads>>>(compactedVoxelArray, voxelOccupied,
+                                   voxelOccupiedScan, numVoxels);
+  getLastCudaError("compactVoxels failed");
+}
+
+// compute interpolated vertex along an edge
+__device__ float3 vertexInterp(float isolevel, float3 p0, float3 p1, float f0,
+                               float f1) {
+  float t = (isolevel - f0) / (f1 - f0);
+  return lerp(p0, p1, t);
+}
+
+// compute interpolated vertex position and normal along an edge
+__device__ void vertexInterp2(float isolevel, float3 p0, float3 p1, float4 f0,
+                              float4 f1, float3 &p, float3 &n) {
+  float t = (isolevel - f0.w) / (f1.w - f0.w);
+  p = lerp(p0, p1, t);
+  n.x = lerp(f0.x, f1.x, t);
+  n.y = lerp(f0.y, f1.y, t);
+  n.z = lerp(f0.z, f1.z, t);
+  //    n = normalize(n);
+}
+
+// generate triangles for each voxel using marching cubes
+// interpolates normals from field function
+__global__ void generateTriangles(
+    float4 *pos, float4 *norm, uint *compactedVoxelArray, uint *numVertsScanned,
+    uint3 gridSize, uint3 gridSizeShift, uint3 gridSizeMask, float3 voxelSize,
+    float isoValue, uint activeVoxels, uint maxVerts,
+    cudaTextureObject_t triTex, cudaTextureObject_t numVertsTex) {
+  uint blockId = __mul24(blockIdx.y, gridDim.x) + blockIdx.x;
+  uint i = __mul24(blockId, blockDim.x) + threadIdx.x;
+
+  if (i > activeVoxels - 1) {
+    // can't return here because of syncthreads()
+    i = activeVoxels - 1;
+  }
+
+#if SKIP_EMPTY_VOXELS
+  uint voxel = compactedVoxelArray[i];
+#else
+  uint voxel = i;
+#endif
+
+  // compute position in 3d grid
+  uint3 gridPos = calcGridPos(voxel, gridSizeShift, gridSizeMask);
+
+  float3 p;
+  p.x = -1.0f + (gridPos.x * voxelSize.x);
+  p.y = -1.0f + (gridPos.y * voxelSize.y);
+  p.z = -1.0f + (gridPos.z * voxelSize.z);
+
+  // calculate cell vertex positions
+  float3 v[8];
+  v[0] = p;
+  v[1] = p + make_float3(voxelSize.x, 0, 0);
+  v[2] = p + make_float3(voxelSize.x, voxelSize.y, 0);
+  v[3] = p + make_float3(0, voxelSize.y, 0);
+  v[4] = p + make_float3(0, 0, voxelSize.z);
+  v[5] = p + make_float3(voxelSize.x, 0, voxelSize.z);
+  v[6] = p + make_float3(voxelSize.x, voxelSize.y, voxelSize.z);
+  v[7] = p + make_float3(0, voxelSize.y, voxelSize.z);
+
+  // evaluate field values
+  float4 field[8];
+  field[0] = fieldFunc4(v[0]);
+  field[1] = fieldFunc4(v[1]);
+  field[2] = fieldFunc4(v[2]);
+  field[3] = fieldFunc4(v[3]);
+  field[4] = fieldFunc4(v[4]);
+  field[5] = fieldFunc4(v[5]);
+  field[6] = fieldFunc4(v[6]);
+  field[7] = fieldFunc4(v[7]);
+
+  // recalculate flag
+  // (this is faster than storing it in global memory)
+  uint cubeindex;
+  cubeindex = uint(field[0].w < isoValue);
+  cubeindex += uint(field[1].w < isoValue) * 2;
+  cubeindex += uint(field[2].w < isoValue) * 4;
+  cubeindex += uint(field[3].w < isoValue) * 8;
+  cubeindex += uint(field[4].w < isoValue) * 16;
+  cubeindex += uint(field[5].w < isoValue) * 32;
+  cubeindex += uint(field[6].w < isoValue) * 64;
+  cubeindex += uint(field[7].w < isoValue) * 128;
+
+// find the vertices where the surface intersects the cube
+
+#if USE_SHARED
+  // use partioned shared memory to avoid using local memory
+  __shared__ float3 vertlist[12 * NTHREADS];
+  __shared__ float3 normlist[12 * NTHREADS];
+
+  vertexInterp2(isoValue, v[0], v[1], field[0], field[1], vertlist[threadIdx.x],
+                normlist[threadIdx.x]);
+  vertexInterp2(isoValue, v[1], v[2], field[1], field[2],
+                vertlist[threadIdx.x + NTHREADS],
+                normlist[threadIdx.x + NTHREADS]);
+  vertexInterp2(isoValue, v[2], v[3], field[2], field[3],
+                vertlist[threadIdx.x + (NTHREADS * 2)],
+                normlist[threadIdx.x + (NTHREADS * 2)]);
+  vertexInterp2(isoValue, v[3], v[0], field[3], field[0],
+                vertlist[threadIdx.x + (NTHREADS * 3)],
+                normlist[threadIdx.x + (NTHREADS * 3)]);
+  vertexInterp2(isoValue, v[4], v[5], field[4], field[5],
+                vertlist[threadIdx.x + (NTHREADS * 4)],
+                normlist[threadIdx.x + (NTHREADS * 4)]);
+  vertexInterp2(isoValue, v[5], v[6], field[5], field[6],
+                vertlist[threadIdx.x + (NTHREADS * 5)],
+                normlist[threadIdx.x + (NTHREADS * 5)]);
+  vertexInterp2(isoValue, v[6], v[7], field[6], field[7],
+                vertlist[threadIdx.x + (NTHREADS * 6)],
+                normlist[threadIdx.x + (NTHREADS * 6)]);
+  vertexInterp2(isoValue, v[7], v[4], field[7], field[4],
+                vertlist[threadIdx.x + (NTHREADS * 7)],
+                normlist[threadIdx.x + (NTHREADS * 7)]);
+  vertexInterp2(isoValue, v[0], v[4], field[0], field[4],
+                vertlist[threadIdx.x + (NTHREADS * 8)],
+                normlist[threadIdx.x + (NTHREADS * 8)]);
+  vertexInterp2(isoValue, v[1], v[5], field[1], field[5],
+                vertlist[threadIdx.x + (NTHREADS * 9)],
+                normlist[threadIdx.x + (NTHREADS * 9)]);
+  vertexInterp2(isoValue, v[2], v[6], field[2], field[6],
+                vertlist[threadIdx.x + (NTHREADS * 10)],
+                normlist[threadIdx.x + (NTHREADS * 10)]);
+  vertexInterp2(isoValue, v[3], v[7], field[3], field[7],
+                vertlist[threadIdx.x + (NTHREADS * 11)],
+                normlist[threadIdx.x + (NTHREADS * 11)]);
+  __syncthreads();
+
+#else
+  float3 vertlist[12];
+  float3 normlist[12];
+
+  vertexInterp2(isoValue, v[0], v[1], field[0], field[1], vertlist[0],
+                normlist[0]);
+  vertexInterp2(isoValue, v[1], v[2], field[1], field[2], vertlist[1],
+                normlist[1]);
+  vertexInterp2(isoValue, v[2], v[3], field[2], field[3], vertlist[2],
+                normlist[2]);
+  vertexInterp2(isoValue, v[3], v[0], field[3], field[0], vertlist[3],
+                normlist[3]);
+
+  vertexInterp2(isoValue, v[4], v[5], field[4], field[5], vertlist[4],
+                normlist[4]);
+  vertexInterp2(isoValue, v[5], v[6], field[5], field[6], vertlist[5],
+                normlist[5]);
+  vertexInterp2(isoValue, v[6], v[7], field[6], field[7], vertlist[6],
+                normlist[6]);
+  vertexInterp2(isoValue, v[7], v[4], field[7], field[4], vertlist[7],
+                normlist[7]);
+
+  vertexInterp2(isoValue, v[0], v[4], field[0], field[4], vertlist[8],
+                normlist[8]);
+  vertexInterp2(isoValue, v[1], v[5], field[1], field[5], vertlist[9],
+                normlist[9]);
+  vertexInterp2(isoValue, v[2], v[6], field[2], field[6], vertlist[10],
+                normlist[10]);
+  vertexInterp2(isoValue, v[3], v[7], field[3], field[7], vertlist[11],
+                normlist[11]);
+#endif
+
+  // output triangle vertices
+  uint numVerts = tex1Dfetch<uint>(numVertsTex, cubeindex);
+
+  for (int i = 0; i < numVerts; i++) {
+    uint edge = tex1Dfetch<uint>(triTex, cubeindex * 16 + i);
+
+    uint index = numVertsScanned[voxel] + i;
+
+    if (index < maxVerts) {
+#if USE_SHARED
+      pos[index] = make_float4(vertlist[(edge * NTHREADS) + threadIdx.x], 1.0f);
+      norm[index] =
+          make_float4(normlist[(edge * NTHREADS) + threadIdx.x], 0.0f);
+#else
+      pos[index] = make_float4(vertlist[edge], 1.0f);
+      norm[index] = make_float4(normlist[edge], 0.0f);
+#endif
+    }
+  }
+}
+
+extern "C" void launch_generateTriangles(
+    dim3 grid, dim3 threads, float4 *pos, float4 *norm,
+    uint *compactedVoxelArray, uint *numVertsScanned, uint3 gridSize,
+    uint3 gridSizeShift, uint3 gridSizeMask, float3 voxelSize, float isoValue,
+    uint activeVoxels, uint maxVerts) {
+  generateTriangles<<<grid, NTHREADS>>>(
+      pos, norm, compactedVoxelArray, numVertsScanned, gridSize, gridSizeShift,
+      gridSizeMask, voxelSize, isoValue, activeVoxels, maxVerts, triTex,
+      numVertsTex);
+  getLastCudaError("generateTriangles failed");
+}
+
+// calculate triangle normal
+__device__ float3 calcNormal(float3 *v0, float3 *v1, float3 *v2) {
+  float3 edge0 = *v1 - *v0;
+  float3 edge1 = *v2 - *v0;
+  // note - it's faster to perform normalization in vertex shader rather than
+  // here
+  return cross(edge0, edge1);
+}
+
+// version that calculates flat surface normal for each triangle
+__global__ void generateTriangles2(
+    float4 *pos, float4 *norm, uint *compactedVoxelArray, uint *numVertsScanned,
+    uchar *volume, uint3 gridSize, uint3 gridSizeShift, uint3 gridSizeMask,
+    float3 voxelSize, float isoValue, uint activeVoxels, uint maxVerts,
+    cudaTextureObject_t triTex, cudaTextureObject_t numVertsTex,
+    cudaTextureObject_t volumeTex) {
+  uint blockId = __mul24(blockIdx.y, gridDim.x) + blockIdx.x;
+  uint i = __mul24(blockId, blockDim.x) + threadIdx.x;
+
+  if (i > activeVoxels - 1) {
+    i = activeVoxels - 1;
+  }
+
+#if SKIP_EMPTY_VOXELS
+  uint voxel = compactedVoxelArray[i];
+#else
+  uint voxel = i;
+#endif
+
+  // compute position in 3d grid
+  uint3 gridPos = calcGridPos(voxel, gridSizeShift, gridSizeMask);
+
+  float3 p;
+  p.x = -1.0f + (gridPos.x * voxelSize.x);
+  p.y = -1.0f + (gridPos.y * voxelSize.y);
+  p.z = -1.0f + (gridPos.z * voxelSize.z);
+
+  // calculate cell vertex positions
+  float3 v[8];
+  v[0] = p;
+  v[1] = p + make_float3(voxelSize.x, 0, 0);
+  v[2] = p + make_float3(voxelSize.x, voxelSize.y, 0);
+  v[3] = p + make_float3(0, voxelSize.y, 0);
+  v[4] = p + make_float3(0, 0, voxelSize.z);
+  v[5] = p + make_float3(voxelSize.x, 0, voxelSize.z);
+  v[6] = p + make_float3(voxelSize.x, voxelSize.y, voxelSize.z);
+  v[7] = p + make_float3(0, voxelSize.y, voxelSize.z);
+
+#if SAMPLE_VOLUME
+  float field[8];
+  field[0] = sampleVolume(volumeTex, volume, gridPos, gridSize);
+  field[1] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(1, 0, 0), gridSize);
+  field[2] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(1, 1, 0), gridSize);
+  field[3] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(0, 1, 0), gridSize);
+  field[4] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(0, 0, 1), gridSize);
+  field[5] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(1, 0, 1), gridSize);
+  field[6] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(1, 1, 1), gridSize);
+  field[7] =
+      sampleVolume(volumeTex, volume, gridPos + make_uint3(0, 1, 1), gridSize);
+#else
+  // evaluate field values
+  float field[8];
+  field[0] = fieldFunc(v[0]);
+  field[1] = fieldFunc(v[1]);
+  field[2] = fieldFunc(v[2]);
+  field[3] = fieldFunc(v[3]);
+  field[4] = fieldFunc(v[4]);
+  field[5] = fieldFunc(v[5]);
+  field[6] = fieldFunc(v[6]);
+  field[7] = fieldFunc(v[7]);
+#endif
+
+  // recalculate flag
+  uint cubeindex;
+  cubeindex = uint(field[0] < isoValue);
+  cubeindex += uint(field[1] < isoValue) * 2;
+  cubeindex += uint(field[2] < isoValue) * 4;
+  cubeindex += uint(field[3] < isoValue) * 8;
+  cubeindex += uint(field[4] < isoValue) * 16;
+  cubeindex += uint(field[5] < isoValue) * 32;
+  cubeindex += uint(field[6] < isoValue) * 64;
+  cubeindex += uint(field[7] < isoValue) * 128;
+
+// find the vertices where the surface intersects the cube
+
+#if USE_SHARED
+  // use shared memory to avoid using local
+  __shared__ float3 vertlist[12 * NTHREADS];
+
+  vertlist[threadIdx.x] =
+      vertexInterp(isoValue, v[0], v[1], field[0], field[1]);
+  vertlist[NTHREADS + threadIdx.x] =
+      vertexInterp(isoValue, v[1], v[2], field[1], field[2]);
+  vertlist[(NTHREADS * 2) + threadIdx.x] =
+      vertexInterp(isoValue, v[2], v[3], field[2], field[3]);
+  vertlist[(NTHREADS * 3) + threadIdx.x] =
+      vertexInterp(isoValue, v[3], v[0], field[3], field[0]);
+  vertlist[(NTHREADS * 4) + threadIdx.x] =
+      vertexInterp(isoValue, v[4], v[5], field[4], field[5]);
+  vertlist[(NTHREADS * 5) + threadIdx.x] =
+      vertexInterp(isoValue, v[5], v[6], field[5], field[6]);
+  vertlist[(NTHREADS * 6) + threadIdx.x] =
+      vertexInterp(isoValue, v[6], v[7], field[6], field[7]);
+  vertlist[(NTHREADS * 7) + threadIdx.x] =
+      vertexInterp(isoValue, v[7], v[4], field[7], field[4]);
+  vertlist[(NTHREADS * 8) + threadIdx.x] =
+      vertexInterp(isoValue, v[0], v[4], field[0], field[4]);
+  vertlist[(NTHREADS * 9) + threadIdx.x] =
+      vertexInterp(isoValue, v[1], v[5], field[1], field[5]);
+  vertlist[(NTHREADS * 10) + threadIdx.x] =
+      vertexInterp(isoValue, v[2], v[6], field[2], field[6]);
+  vertlist[(NTHREADS * 11) + threadIdx.x] =
+      vertexInterp(isoValue, v[3], v[7], field[3], field[7]);
+  __syncthreads();
+#else
+
+  float3 vertlist[12];
+
+  vertlist[0] = vertexInterp(isoValue, v[0], v[1], field[0], field[1]);
+  vertlist[1] = vertexInterp(isoValue, v[1], v[2], field[1], field[2]);
+  vertlist[2] = vertexInterp(isoValue, v[2], v[3], field[2], field[3]);
+  vertlist[3] = vertexInterp(isoValue, v[3], v[0], field[3], field[0]);
+
+  vertlist[4] = vertexInterp(isoValue, v[4], v[5], field[4], field[5]);
+  vertlist[5] = vertexInterp(isoValue, v[5], v[6], field[5], field[6]);
+  vertlist[6] = vertexInterp(isoValue, v[6], v[7], field[6], field[7]);
+  vertlist[7] = vertexInterp(isoValue, v[7], v[4], field[7], field[4]);
+
+  vertlist[8] = vertexInterp(isoValue, v[0], v[4], field[0], field[4]);
+  vertlist[9] = vertexInterp(isoValue, v[1], v[5], field[1], field[5]);
+  vertlist[10] = vertexInterp(isoValue, v[2], v[6], field[2], field[6]);
+  vertlist[11] = vertexInterp(isoValue, v[3], v[7], field[3], field[7]);
+#endif
+
+  // output triangle vertices
+  uint numVerts = tex1Dfetch<uint>(numVertsTex, cubeindex);
+
+  for (int i = 0; i < numVerts; i += 3) {
+    uint index = numVertsScanned[voxel] + i;
+
+    float3 *v[3];
+    uint edge;
+    edge = tex1Dfetch<uint>(triTex, (cubeindex * 16) + i);
+#if USE_SHARED
+    v[0] = &vertlist[(edge * NTHREADS) + threadIdx.x];
+#else
+    v[0] = &vertlist[edge];
+#endif
+
+    edge = tex1Dfetch<uint>(triTex, (cubeindex * 16) + i + 1);
+#if USE_SHARED
+    v[1] = &vertlist[(edge * NTHREADS) + threadIdx.x];
+#else
+    v[1] = &vertlist[edge];
+#endif
+
+    edge = tex1Dfetch<uint>(triTex, (cubeindex * 16) + i + 2);
+#if USE_SHARED
+    v[2] = &vertlist[(edge * NTHREADS) + threadIdx.x];
+#else
+    v[2] = &vertlist[edge];
+#endif
+
+    // calculate triangle surface normal
+    float3 n = calcNormal(v[0], v[1], v[2]);
+
+    if (index < (maxVerts - 3)) {
+      pos[index] = make_float4(*v[0], 1.0f);
+      norm[index] = make_float4(n, 0.0f);
+
+      pos[index + 1] = make_float4(*v[1], 1.0f);
+      norm[index + 1] = make_float4(n, 0.0f);
+
+      pos[index + 2] = make_float4(*v[2], 1.0f);
+      norm[index + 2] = make_float4(n, 0.0f);
+    }
+  }
+}
+
+extern "C" void launch_generateTriangles2(
+    dim3 grid, dim3 threads, float4 *pos, float4 *norm,
+    uint *compactedVoxelArray, uint *numVertsScanned, uchar *volume,
+    uint3 gridSize, uint3 gridSizeShift, uint3 gridSizeMask, float3 voxelSize,
+    float isoValue, uint activeVoxels, uint maxVerts) {
+  generateTriangles2<<<grid, NTHREADS>>>(
+      pos, norm, compactedVoxelArray, numVertsScanned, volume, gridSize,
+      gridSizeShift, gridSizeMask, voxelSize, isoValue, activeVoxels, maxVerts,
+      triTex, numVertsTex, volumeTex);
+  getLastCudaError("generateTriangles2 failed");
+}
+
+extern "C" void ThrustScanWrapper(unsigned int *output, unsigned int *input,
+                                  unsigned int numElements) {
+  thrust::exclusive_scan(thrust::device_ptr<unsigned int>(input),
+                         thrust::device_ptr<unsigned int>(input + numElements),
+                         thrust::device_ptr<unsigned int>(output));
+}
+
+#endif
--- a/Samples/marchingCubes/marchingCubes_vs2017.sln
+++ b/Samples/marchingCubes/marchingCubes_vs2017.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "marchingCubes", "marchingCubes_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
--- a/Samples/marchingCubes/marchingCubes_vs2017.vcxproj
+++ b/Samples/marchingCubes/marchingCubes_vs2017.vcxproj
@@ -0,0 +1,125 @@
+<?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>marchingCubes_vs2017</RootNamespace>
+    <ProjectName>marchingCubes</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 11.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;freeglut.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);../../Common/lib/$(PlatformName);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/marchingCubes.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;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;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
+      <Include>./;../../Common</Include>
+      <Defines>WIN32</Defines>
+      <AdditionalOptions>--threads 0</AdditionalOptions>
+    </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>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
+    <Link>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='x64'">
+    <Link>
+      <AdditionalDependencies>glew64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="marchingCubes.cpp" />
+    <CudaCompile Include="marchingCubes_kernel.cu" />
+    <ClInclude Include="defines.h" />
+    <ClInclude Include="tables.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
+  </ImportGroup>
+</Project>
--- a/Samples/marchingCubes/marchingCubes_vs2019.sln
+++ b/Samples/marchingCubes/marchingCubes_vs2019.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "marchingCubes", "marchingCubes_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
--- a/Samples/marchingCubes/marchingCubes_vs2019.vcxproj
+++ b/Samples/marchingCubes/marchingCubes_vs2019.vcxproj
@@ -0,0 +1,121 @@
+<?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>marchingCubes_vs2019</RootNamespace>
+    <ProjectName>marchingCubes</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 11.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;freeglut.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);../../Common/lib/$(PlatformName);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/marchingCubes.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;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;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
+      <Include>./;../../Common</Include>
+      <Defines>WIN32</Defines>
+      <AdditionalOptions>--threads 0</AdditionalOptions>
+    </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>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
+    <Link>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='x64'">
+    <Link>
+      <AdditionalDependencies>glew64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="marchingCubes.cpp" />
+    <CudaCompile Include="marchingCubes_kernel.cu" />
+    <ClInclude Include="defines.h" />
+    <ClInclude Include="tables.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
+  </ImportGroup>
+</Project>
--- a/Samples/marchingCubes/tables.h
+++ b/Samples/marchingCubes/tables.h
@@ -0,0 +1,338 @@
+/* Copyright (c) 2021, 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.
+ */
+
+/*
+  Tables for Marching Cubes
+  http://local.wasp.uwa.edu.au/~pbourke/geometry/polygonise/
+*/
+
+// edge table maps 8-bit flag representing which cube vertices are inside
+// the isosurface to 12-bit number indicating which edges are intersected
+uint edgeTable[256] = {
+    0x0,   0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c, 0x80c, 0x905, 0xa0f,
+    0xb06, 0xc0a, 0xd03, 0xe09, 0xf00, 0x190, 0x99,  0x393, 0x29a, 0x596, 0x49f,
+    0x795, 0x69c, 0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90, 0x230,
+    0x339, 0x33,  0x13a, 0x636, 0x73f, 0x435, 0x53c, 0xa3c, 0xb35, 0x83f, 0x936,
+    0xe3a, 0xf33, 0xc39, 0xd30, 0x3a0, 0x2a9, 0x1a3, 0xaa,  0x7a6, 0x6af, 0x5a5,
+    0x4ac, 0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0, 0x460, 0x569,
+    0x663, 0x76a, 0x66,  0x16f, 0x265, 0x36c, 0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a,
+    0x963, 0xa69, 0xb60, 0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff,  0x3f5, 0x2fc,
+    0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0, 0x650, 0x759, 0x453,
+    0x55a, 0x256, 0x35f, 0x55,  0x15c, 0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53,
+    0x859, 0x950, 0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0xcc,  0xfcc,
+    0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0, 0x8c0, 0x9c9, 0xac3, 0xbca,
+    0xcc6, 0xdcf, 0xec5, 0xfcc, 0xcc,  0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9,
+    0x7c0, 0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c, 0x15c, 0x55,
+    0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650, 0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6,
+    0xfff, 0xcf5, 0xdfc, 0x2fc, 0x3f5, 0xff,  0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
+    0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c, 0x36c, 0x265, 0x16f,
+    0x66,  0x76a, 0x663, 0x569, 0x460, 0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af,
+    0xaa5, 0xbac, 0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa,  0x1a3, 0x2a9, 0x3a0, 0xd30,
+    0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c, 0x53c, 0x435, 0x73f, 0x636,
+    0x13a, 0x33,  0x339, 0x230, 0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895,
+    0x99c, 0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x99,  0x190, 0xf00, 0xe09,
+    0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c, 0x70c, 0x605, 0x50f, 0x406, 0x30a,
+    0x203, 0x109, 0x0};
+
+// triangle table maps same cube vertex index to a list of up to 5 triangles
+// which are built from the interpolated edge vertices
+#define X 255
+uint triTable[256][16] = {{X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {0, 8, 3, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {0, 1, 9, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {1, 8, 3, 9, 8, 1, X, X, X, X, X, X, X, X, X, X},
+                          {1, 2, 10, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {0, 8, 3, 1, 2, 10, X, X, X, X, X, X, X, X, X, X},
+                          {9, 2, 10, 0, 2, 9, X, X, X, X, X, X, X, X, X, X},
+                          {2, 8, 3, 2, 10, 8, 10, 9, 8, X, X, X, X, X, X, X},
+                          {3, 11, 2, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {0, 11, 2, 8, 11, 0, X, X, X, X, X, X, X, X, X, X},
+                          {1, 9, 0, 2, 3, 11, X, X, X, X, X, X, X, X, X, X},
+                          {1, 11, 2, 1, 9, 11, 9, 8, 11, X, X, X, X, X, X, X},
+                          {3, 10, 1, 11, 10, 3, X, X, X, X, X, X, X, X, X, X},
+                          {0, 10, 1, 0, 8, 10, 8, 11, 10, X, X, X, X, X, X, X},
+                          {3, 9, 0, 3, 11, 9, 11, 10, 9, X, X, X, X, X, X, X},
+                          {9, 8, 10, 10, 8, 11, X, X, X, X, X, X, X, X, X, X},
+                          {4, 7, 8, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {4, 3, 0, 7, 3, 4, X, X, X, X, X, X, X, X, X, X},
+                          {0, 1, 9, 8, 4, 7, X, X, X, X, X, X, X, X, X, X},
+                          {4, 1, 9, 4, 7, 1, 7, 3, 1, X, X, X, X, X, X, X},
+                          {1, 2, 10, 8, 4, 7, X, X, X, X, X, X, X, X, X, X},
+                          {3, 4, 7, 3, 0, 4, 1, 2, 10, X, X, X, X, X, X, X},
+                          {9, 2, 10, 9, 0, 2, 8, 4, 7, X, X, X, X, X, X, X},
+                          {2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, X, X, X, X},
+                          {8, 4, 7, 3, 11, 2, X, X, X, X, X, X, X, X, X, X},
+                          {11, 4, 7, 11, 2, 4, 2, 0, 4, X, X, X, X, X, X, X},
+                          {9, 0, 1, 8, 4, 7, 2, 3, 11, X, X, X, X, X, X, X},
+                          {4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, X, X, X, X},
+                          {3, 10, 1, 3, 11, 10, 7, 8, 4, X, X, X, X, X, X, X},
+                          {1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, X, X, X, X},
+                          {4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, X, X, X, X},
+                          {4, 7, 11, 4, 11, 9, 9, 11, 10, X, X, X, X, X, X, X},
+                          {9, 5, 4, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {9, 5, 4, 0, 8, 3, X, X, X, X, X, X, X, X, X, X},
+                          {0, 5, 4, 1, 5, 0, X, X, X, X, X, X, X, X, X, X},
+                          {8, 5, 4, 8, 3, 5, 3, 1, 5, X, X, X, X, X, X, X},
+                          {1, 2, 10, 9, 5, 4, X, X, X, X, X, X, X, X, X, X},
+                          {3, 0, 8, 1, 2, 10, 4, 9, 5, X, X, X, X, X, X, X},
+                          {5, 2, 10, 5, 4, 2, 4, 0, 2, X, X, X, X, X, X, X},
+                          {2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, X, X, X, X},
+                          {9, 5, 4, 2, 3, 11, X, X, X, X, X, X, X, X, X, X},
+                          {0, 11, 2, 0, 8, 11, 4, 9, 5, X, X, X, X, X, X, X},
+                          {0, 5, 4, 0, 1, 5, 2, 3, 11, X, X, X, X, X, X, X},
+                          {2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, X, X, X, X},
+                          {10, 3, 11, 10, 1, 3, 9, 5, 4, X, X, X, X, X, X, X},
+                          {4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, X, X, X, X},
+                          {5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, X, X, X, X},
+                          {5, 4, 8, 5, 8, 10, 10, 8, 11, X, X, X, X, X, X, X},
+                          {9, 7, 8, 5, 7, 9, X, X, X, X, X, X, X, X, X, X},
+                          {9, 3, 0, 9, 5, 3, 5, 7, 3, X, X, X, X, X, X, X},
+                          {0, 7, 8, 0, 1, 7, 1, 5, 7, X, X, X, X, X, X, X},
+                          {1, 5, 3, 3, 5, 7, X, X, X, X, X, X, X, X, X, X},
+                          {9, 7, 8, 9, 5, 7, 10, 1, 2, X, X, X, X, X, X, X},
+                          {10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, X, X, X, X},
+                          {8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, X, X, X, X},
+                          {2, 10, 5, 2, 5, 3, 3, 5, 7, X, X, X, X, X, X, X},
+                          {7, 9, 5, 7, 8, 9, 3, 11, 2, X, X, X, X, X, X, X},
+                          {9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, X, X, X, X},
+                          {2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, X, X, X, X},
+                          {11, 2, 1, 11, 1, 7, 7, 1, 5, X, X, X, X, X, X, X},
+                          {9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, X, X, X, X},
+                          {5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, X},
+                          {11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, X},
+                          {11, 10, 5, 7, 11, 5, X, X, X, X, X, X, X, X, X, X},
+                          {10, 6, 5, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {0, 8, 3, 5, 10, 6, X, X, X, X, X, X, X, X, X, X},
+                          {9, 0, 1, 5, 10, 6, X, X, X, X, X, X, X, X, X, X},
+                          {1, 8, 3, 1, 9, 8, 5, 10, 6, X, X, X, X, X, X, X},
+                          {1, 6, 5, 2, 6, 1, X, X, X, X, X, X, X, X, X, X},
+                          {1, 6, 5, 1, 2, 6, 3, 0, 8, X, X, X, X, X, X, X},
+                          {9, 6, 5, 9, 0, 6, 0, 2, 6, X, X, X, X, X, X, X},
+                          {5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, X, X, X, X},
+                          {2, 3, 11, 10, 6, 5, X, X, X, X, X, X, X, X, X, X},
+                          {11, 0, 8, 11, 2, 0, 10, 6, 5, X, X, X, X, X, X, X},
+                          {0, 1, 9, 2, 3, 11, 5, 10, 6, X, X, X, X, X, X, X},
+                          {5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, X, X, X, X},
+                          {6, 3, 11, 6, 5, 3, 5, 1, 3, X, X, X, X, X, X, X},
+                          {0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, X, X, X, X},
+                          {3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, X, X, X, X},
+                          {6, 5, 9, 6, 9, 11, 11, 9, 8, X, X, X, X, X, X, X},
+                          {5, 10, 6, 4, 7, 8, X, X, X, X, X, X, X, X, X, X},
+                          {4, 3, 0, 4, 7, 3, 6, 5, 10, X, X, X, X, X, X, X},
+                          {1, 9, 0, 5, 10, 6, 8, 4, 7, X, X, X, X, X, X, X},
+                          {10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, X, X, X, X},
+                          {6, 1, 2, 6, 5, 1, 4, 7, 8, X, X, X, X, X, X, X},
+                          {1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, X, X, X, X},
+                          {8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, X, X, X, X},
+                          {7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, X},
+                          {3, 11, 2, 7, 8, 4, 10, 6, 5, X, X, X, X, X, X, X},
+                          {5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, X, X, X, X},
+                          {0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, X, X, X, X},
+                          {9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, X},
+                          {8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, X, X, X, X},
+                          {5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, X},
+                          {0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, X},
+                          {6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, X, X, X, X},
+                          {10, 4, 9, 6, 4, 10, X, X, X, X, X, X, X, X, X, X},
+                          {4, 10, 6, 4, 9, 10, 0, 8, 3, X, X, X, X, X, X, X},
+                          {10, 0, 1, 10, 6, 0, 6, 4, 0, X, X, X, X, X, X, X},
+                          {8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, X, X, X, X},
+                          {1, 4, 9, 1, 2, 4, 2, 6, 4, X, X, X, X, X, X, X},
+                          {3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, X, X, X, X},
+                          {0, 2, 4, 4, 2, 6, X, X, X, X, X, X, X, X, X, X},
+                          {8, 3, 2, 8, 2, 4, 4, 2, 6, X, X, X, X, X, X, X},
+                          {10, 4, 9, 10, 6, 4, 11, 2, 3, X, X, X, X, X, X, X},
+                          {0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, X, X, X, X},
+                          {3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, X, X, X, X},
+                          {6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, X},
+                          {9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, X, X, X, X},
+                          {8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, X},
+                          {3, 11, 6, 3, 6, 0, 0, 6, 4, X, X, X, X, X, X, X},
+                          {6, 4, 8, 11, 6, 8, X, X, X, X, X, X, X, X, X, X},
+                          {7, 10, 6, 7, 8, 10, 8, 9, 10, X, X, X, X, X, X, X},
+                          {0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, X, X, X, X},
+                          {10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, X, X, X, X},
+                          {10, 6, 7, 10, 7, 1, 1, 7, 3, X, X, X, X, X, X, X},
+                          {1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, X, X, X, X},
+                          {2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, X},
+                          {7, 8, 0, 7, 0, 6, 6, 0, 2, X, X, X, X, X, X, X},
+                          {7, 3, 2, 6, 7, 2, X, X, X, X, X, X, X, X, X, X},
+                          {2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, X, X, X, X},
+                          {2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, X},
+                          {1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, X},
+                          {11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, X, X, X, X},
+                          {8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, X},
+                          {0, 9, 1, 11, 6, 7, X, X, X, X, X, X, X, X, X, X},
+                          {7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, X, X, X, X},
+                          {7, 11, 6, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {7, 6, 11, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {3, 0, 8, 11, 7, 6, X, X, X, X, X, X, X, X, X, X},
+                          {0, 1, 9, 11, 7, 6, X, X, X, X, X, X, X, X, X, X},
+                          {8, 1, 9, 8, 3, 1, 11, 7, 6, X, X, X, X, X, X, X},
+                          {10, 1, 2, 6, 11, 7, X, X, X, X, X, X, X, X, X, X},
+                          {1, 2, 10, 3, 0, 8, 6, 11, 7, X, X, X, X, X, X, X},
+                          {2, 9, 0, 2, 10, 9, 6, 11, 7, X, X, X, X, X, X, X},
+                          {6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, X, X, X, X},
+                          {7, 2, 3, 6, 2, 7, X, X, X, X, X, X, X, X, X, X},
+                          {7, 0, 8, 7, 6, 0, 6, 2, 0, X, X, X, X, X, X, X},
+                          {2, 7, 6, 2, 3, 7, 0, 1, 9, X, X, X, X, X, X, X},
+                          {1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, X, X, X, X},
+                          {10, 7, 6, 10, 1, 7, 1, 3, 7, X, X, X, X, X, X, X},
+                          {10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, X, X, X, X},
+                          {0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, X, X, X, X},
+                          {7, 6, 10, 7, 10, 8, 8, 10, 9, X, X, X, X, X, X, X},
+                          {6, 8, 4, 11, 8, 6, X, X, X, X, X, X, X, X, X, X},
+                          {3, 6, 11, 3, 0, 6, 0, 4, 6, X, X, X, X, X, X, X},
+                          {8, 6, 11, 8, 4, 6, 9, 0, 1, X, X, X, X, X, X, X},
+                          {9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, X, X, X, X},
+                          {6, 8, 4, 6, 11, 8, 2, 10, 1, X, X, X, X, X, X, X},
+                          {1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, X, X, X, X},
+                          {4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, X, X, X, X},
+                          {10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, X},
+                          {8, 2, 3, 8, 4, 2, 4, 6, 2, X, X, X, X, X, X, X},
+                          {0, 4, 2, 4, 6, 2, X, X, X, X, X, X, X, X, X, X},
+                          {1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, X, X, X, X},
+                          {1, 9, 4, 1, 4, 2, 2, 4, 6, X, X, X, X, X, X, X},
+                          {8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, X, X, X, X},
+                          {10, 1, 0, 10, 0, 6, 6, 0, 4, X, X, X, X, X, X, X},
+                          {4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, X},
+                          {10, 9, 4, 6, 10, 4, X, X, X, X, X, X, X, X, X, X},
+                          {4, 9, 5, 7, 6, 11, X, X, X, X, X, X, X, X, X, X},
+                          {0, 8, 3, 4, 9, 5, 11, 7, 6, X, X, X, X, X, X, X},
+                          {5, 0, 1, 5, 4, 0, 7, 6, 11, X, X, X, X, X, X, X},
+                          {11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, X, X, X, X},
+                          {9, 5, 4, 10, 1, 2, 7, 6, 11, X, X, X, X, X, X, X},
+                          {6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, X, X, X, X},
+                          {7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, X, X, X, X},
+                          {3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, X},
+                          {7, 2, 3, 7, 6, 2, 5, 4, 9, X, X, X, X, X, X, X},
+                          {9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, X, X, X, X},
+                          {3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, X, X, X, X},
+                          {6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, X},
+                          {9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, X, X, X, X},
+                          {1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, X},
+                          {4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, X},
+                          {7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, X, X, X, X},
+                          {6, 9, 5, 6, 11, 9, 11, 8, 9, X, X, X, X, X, X, X},
+                          {3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, X, X, X, X},
+                          {0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, X, X, X, X},
+                          {6, 11, 3, 6, 3, 5, 5, 3, 1, X, X, X, X, X, X, X},
+                          {1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, X, X, X, X},
+                          {0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, X},
+                          {11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, X},
+                          {6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, X, X, X, X},
+                          {5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, X, X, X, X},
+                          {9, 5, 6, 9, 6, 0, 0, 6, 2, X, X, X, X, X, X, X},
+                          {1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, X},
+                          {1, 5, 6, 2, 1, 6, X, X, X, X, X, X, X, X, X, X},
+                          {1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, X},
+                          {10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, X, X, X, X},
+                          {0, 3, 8, 5, 6, 10, X, X, X, X, X, X, X, X, X, X},
+                          {10, 5, 6, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {11, 5, 10, 7, 5, 11, X, X, X, X, X, X, X, X, X, X},
+                          {11, 5, 10, 11, 7, 5, 8, 3, 0, X, X, X, X, X, X, X},
+                          {5, 11, 7, 5, 10, 11, 1, 9, 0, X, X, X, X, X, X, X},
+                          {10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, X, X, X, X},
+                          {11, 1, 2, 11, 7, 1, 7, 5, 1, X, X, X, X, X, X, X},
+                          {0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, X, X, X, X},
+                          {9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, X, X, X, X},
+                          {7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, X},
+                          {2, 5, 10, 2, 3, 5, 3, 7, 5, X, X, X, X, X, X, X},
+                          {8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, X, X, X, X},
+                          {9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, X, X, X, X},
+                          {9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, X},
+                          {1, 3, 5, 3, 7, 5, X, X, X, X, X, X, X, X, X, X},
+                          {0, 8, 7, 0, 7, 1, 1, 7, 5, X, X, X, X, X, X, X},
+                          {9, 0, 3, 9, 3, 5, 5, 3, 7, X, X, X, X, X, X, X},
+                          {9, 8, 7, 5, 9, 7, X, X, X, X, X, X, X, X, X, X},
+                          {5, 8, 4, 5, 10, 8, 10, 11, 8, X, X, X, X, X, X, X},
+                          {5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, X, X, X, X},
+                          {0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, X, X, X, X},
+                          {10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, X},
+                          {2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, X, X, X, X},
+                          {0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, X},
+                          {0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, X},
+                          {9, 4, 5, 2, 11, 3, X, X, X, X, X, X, X, X, X, X},
+                          {2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, X, X, X, X},
+                          {5, 10, 2, 5, 2, 4, 4, 2, 0, X, X, X, X, X, X, X},
+                          {3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, X},
+                          {5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, X, X, X, X},
+                          {8, 4, 5, 8, 5, 3, 3, 5, 1, X, X, X, X, X, X, X},
+                          {0, 4, 5, 1, 0, 5, X, X, X, X, X, X, X, X, X, X},
+                          {8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, X, X, X, X},
+                          {9, 4, 5, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {4, 11, 7, 4, 9, 11, 9, 10, 11, X, X, X, X, X, X, X},
+                          {0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, X, X, X, X},
+                          {1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, X, X, X, X},
+                          {3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, X},
+                          {4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, X, X, X, X},
+                          {9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, X},
+                          {11, 7, 4, 11, 4, 2, 2, 4, 0, X, X, X, X, X, X, X},
+                          {11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, X, X, X, X},
+                          {2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, X, X, X, X},
+                          {9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, X},
+                          {3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, X},
+                          {1, 10, 2, 8, 7, 4, X, X, X, X, X, X, X, X, X, X},
+                          {4, 9, 1, 4, 1, 7, 7, 1, 3, X, X, X, X, X, X, X},
+                          {4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, X, X, X, X},
+                          {4, 0, 3, 7, 4, 3, X, X, X, X, X, X, X, X, X, X},
+                          {4, 8, 7, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {9, 10, 8, 10, 11, 8, X, X, X, X, X, X, X, X, X, X},
+                          {3, 0, 9, 3, 9, 11, 11, 9, 10, X, X, X, X, X, X, X},
+                          {0, 1, 10, 0, 10, 8, 8, 10, 11, X, X, X, X, X, X, X},
+                          {3, 1, 10, 11, 3, 10, X, X, X, X, X, X, X, X, X, X},
+                          {1, 2, 11, 1, 11, 9, 9, 11, 8, X, X, X, X, X, X, X},
+                          {3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, X, X, X, X},
+                          {0, 2, 11, 8, 0, 11, X, X, X, X, X, X, X, X, X, X},
+                          {3, 2, 11, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {2, 3, 8, 2, 8, 10, 10, 8, 9, X, X, X, X, X, X, X},
+                          {9, 10, 2, 0, 9, 2, X, X, X, X, X, X, X, X, X, X},
+                          {2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, X, X, X, X},
+                          {1, 10, 2, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {1, 3, 8, 9, 1, 8, X, X, X, X, X, X, X, X, X, X},
+                          {0, 9, 1, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {0, 3, 8, X, X, X, X, X, X, X, X, X, X, X, X, X},
+                          {X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X}};
+#undef X
+
+// number of vertices for each case above
+uint numVertsTable[256] = {
+    0,  3,  3,  6,  3,  6,  6,  9,  3,  6,  6,  9,  6,  9,  9,  6,  3,  6,  6,
+    9,  6,  9,  9,  12, 6,  9,  9,  12, 9,  12, 12, 9,  3,  6,  6,  9,  6,  9,
+    9,  12, 6,  9,  9,  12, 9,  12, 12, 9,  6,  9,  9,  6,  9,  12, 12, 9,  9,
+    12, 12, 9,  12, 15, 15, 6,  3,  6,  6,  9,  6,  9,  9,  12, 6,  9,  9,  12,
+    9,  12, 12, 9,  6,  9,  9,  12, 9,  12, 12, 15, 9,  12, 12, 15, 12, 15, 15,
+    12, 6,  9,  9,  12, 9,  12, 6,  9,  9,  12, 12, 15, 12, 15, 9,  6,  9,  12,
+    12, 9,  12, 15, 9,  6,  12, 15, 15, 12, 15, 6,  12, 3,  3,  6,  6,  9,  6,
+    9,  9,  12, 6,  9,  9,  12, 9,  12, 12, 9,  6,  9,  9,  12, 9,  12, 12, 15,
+    9,  6,  12, 9,  12, 9,  15, 6,  6,  9,  9,  12, 9,  12, 12, 15, 9,  12, 12,
+    15, 12, 15, 15, 12, 9,  12, 12, 9,  12, 15, 15, 12, 12, 9,  15, 6,  15, 12,
+    6,  3,  6,  9,  9,  12, 9,  12, 12, 15, 9,  12, 12, 15, 6,  9,  9,  6,  9,
+    12, 12, 15, 12, 15, 15, 6,  12, 9,  15, 12, 9,  6,  12, 3,  9,  12, 12, 15,
+    12, 15, 9,  12, 12, 15, 15, 6,  9,  12, 6,  3,  6,  9,  9,  6,  9,  12, 6,
+    3,  9,  6,  12, 3,  6,  3,  3,  0,
+};