lib/NintendoSDK/include/nvn/nvn.h file

Classes

struct NVNdevice

struct NVNdeviceBuilder

struct NVNtextureSparseTileLayout

struct NVNdrawTextureRegion

struct NVNmultisampleState

struct NVNdepthStencilState

struct NVNchannelMaskState

struct NVNpolygonState

struct NVNbufferRange

struct NVNcolorState

struct NVNcounterData

struct NVNseparateTextureHandle

struct NVNseparateSamplerHandle

struct NVNqueue

struct NVNqueueErrorInfo

struct NVNqueueBuilder

struct NVNwindow

struct NVNtexture

struct NVNtextureView

struct NVNcommandBuffer

struct NVNsync

struct NVNrectangle

struct NVNprogram

struct NVNshaderData

struct NVNmemoryPool

struct NVNtexturePool

struct NVNsamplerPool

struct NVNblendState

struct NVNvertexAttribState

struct NVNvertexStreamState

struct NVNmemoryPoolBuilder

struct NVNmappingRequest

struct NVNsamplerBuilder

struct NVNsampler

struct NVNbufferBuilder

struct NVNbuffer

struct NVNevent

struct NVNeventBuilder

struct NVNcopyRegion

struct NVNwindowBuilder

struct NVNtextureBuilder

struct NVNpackagedTextureLayout

Enums

enum NVNdeviceInfo { NVN_DEVICE_INFO_API_MAJOR_VERSION = 0x0, NVN_DEVICE_INFO_API_MINOR_VERSION = 0x1, NVN_DEVICE_INFO_UNIFORM_BUFFER_BINDINGS_PER_STAGE = 0x2, NVN_DEVICE_INFO_MAX_UNIFORM_BUFFER_SIZE = 0x3, NVN_DEVICE_INFO_UNIFORM_BUFFER_ALIGNMENT = 0x4, NVN_DEVICE_INFO_COLOR_BUFFER_BINDINGS = 0x5, NVN_DEVICE_INFO_VERTEX_BUFFER_BINDINGS = 0x6, NVN_DEVICE_INFO_TRANSFORM_FEEDBACK_BUFFER_BINDINGS = 0x7, NVN_DEVICE_INFO_SHADER_STORAGE_BUFFER_BINDINGS_PER_STAGE = 0x8, NVN_DEVICE_INFO_TEXTURE_BINDINGS_PER_STAGE = 0x9, NVN_DEVICE_INFO_COUNTER_ALIGNMENT = 0xA, NVN_DEVICE_INFO_TRANSFORM_FEEDBACK_BUFFER_ALIGNMENT = 0xB, NVN_DEVICE_INFO_TRANSFORM_FEEDBACK_CONTROL_ALIGNMENT = 0xC, NVN_DEVICE_INFO_INDIRECT_DRAW_ALIGNMENT = 0xD, NVN_DEVICE_INFO_VERTEX_ATTRIBUTES = 0xE, NVN_DEVICE_INFO_TEXTURE_DESCRIPTOR_SIZE = 0xF, NVN_DEVICE_INFO_SAMPLER_DESCRIPTOR_SIZE = 0x10, NVN_DEVICE_INFO_RESERVED_TEXTURE_DESCRIPTORS = 0x11, NVN_DEVICE_INFO_RESERVED_SAMPLER_DESCRIPTORS = 0x12, NVN_DEVICE_INFO_COMMAND_BUFFER_COMMAND_ALIGNMENT = 0x13, NVN_DEVICE_INFO_COMMAND_BUFFER_CONTROL_ALIGNMENT = 0x14, NVN_DEVICE_INFO_COMMAND_BUFFER_MIN_COMMAND_SIZE = 0x15, NVN_DEVICE_INFO_COMMAND_BUFFER_MIN_CONTROL_SIZE = 0x16, NVN_DEVICE_INFO_SHADER_SCRATCH_MEMORY_SCALE_FACTOR_MINIMUM = 0x17, NVN_DEVICE_INFO_SHADER_SCRATCH_MEMORY_SCALE_FACTOR_RECOMMENDED = 0x18, NVN_DEVICE_INFO_SHADER_SCRATCH_MEMORY_ALIGNMENT = 0x19, NVN_DEVICE_INFO_SHADER_SCRATCH_MEMORY_GRANULARITY = 0x1A, NVN_DEVICE_INFO_MAX_TEXTURE_ANISOTROPY = 0x1B, NVN_DEVICE_INFO_MAX_COMPUTE_WORK_GROUP_SIZE_X = 0x1C, NVN_DEVICE_INFO_MAX_COMPUTE_WORK_GROUP_SIZE_Y = 0x1D, NVN_DEVICE_INFO_MAX_COMPUTE_WORK_GROUP_SIZE_Z = 0x1E, NVN_DEVICE_INFO_MAX_COMPUTE_WORK_GROUP_SIZE_THREADS = 0x1F, NVN_DEVICE_INFO_MAX_COMPUTE_DISPATCH_WORK_GROUPS_X = 0x20, NVN_DEVICE_INFO_MAX_COMPUTE_DISPATCH_WORK_GROUPS_Y = 0x21, NVN_DEVICE_INFO_MAX_COMPUTE_DISPATCH_WORK_GROUPS_Z = 0x22, NVN_DEVICE_INFO_IMAGE_BINDINGS_PER_STAGE = 0x23, NVN_DEVICE_INFO_MAX_TEXTURE_POOL_SIZE = 0x24, NVN_DEVICE_INFO_MAX_SAMPLER_POOL_SIZE = 0x25, NVN_DEVICE_INFO_MAX_VIEWPORTS = 0x26, NVN_DEVICE_INFO_MEMPOOL_TEXTURE_OBJECT_PAGE_ALIGNMENT = 0x27, NVN_DEVICE_INFO_SUPPORTS_MIN_MAX_FILTERING = 0x28, NVN_DEVICE_INFO_SUPPORTS_STENCIL8_FORMAT = 0x29, NVN_DEVICE_INFO_SUPPORTS_ASTC_FORMATS = 0x2A, NVN_DEVICE_INFO_L2_SIZE = 0x2B, NVN_DEVICE_INFO_MAX_TEXTURE_LEVELS = 0x2C, NVN_DEVICE_INFO_MAX_TEXTURE_LAYERS = 0x2D, NVN_DEVICE_INFO_GLSLC_MAX_SUPPORTED_GPU_CODE_MAJOR_VERSION = 0x2E, NVN_DEVICE_INFO_GLSLC_MIN_SUPPORTED_GPU_CODE_MAJOR_VERSION = 0x2F, NVN_DEVICE_INFO_GLSLC_MAX_SUPPORTED_GPU_CODE_MINOR_VERSION = 0x30, NVN_DEVICE_INFO_GLSLC_MIN_SUPPORTED_GPU_CODE_MINOR_VERSION = 0x31, NVN_DEVICE_INFO_SUPPORTS_CONSERVATIVE_RASTER = 0x32, NVN_DEVICE_INFO_SUBPIXEL_BITS = 0x33, NVN_DEVICE_INFO_MAX_SUBPIXEL_BIAS_BITS = 0x34, NVN_DEVICE_INFO_INDIRECT_DISPATCH_ALIGNMENT = 0x35, NVN_DEVICE_INFO_ZCULL_SAVE_RESTORE_ALIGNMENT = 0x36, NVN_DEVICE_INFO_SHADER_SCRATCH_MEMORY_COMPUTE_SCALE_FACTOR_MINIMUM = 0x37, NVN_DEVICE_INFO_LINEAR_TEXTURE_STRIDE_ALIGNMENT = 0x38, NVN_DEVICE_INFO_LINEAR_RENDER_TARGET_STRIDE_ALIGNMENT = 0x39, NVN_DEVICE_INFO_MEMORY_POOL_PAGE_SIZE = 0x3A, NVN_DEVICE_INFO_SUPPORTS_ZERO_FROM_UNMAPPED_VIRTUAL_POOL_PAGES = 0x3B, NVN_DEVICE_INFO_UNIFORM_BUFFER_UPDATE_ALIGNMENT = 0x3C, NVN_DEVICE_INFO_MAX_TEXTURE_SIZE = 0x3D, NVN_DEVICE_INFO_MAX_BUFFER_TEXTURE_SIZE = 0x3E, NVN_DEVICE_INFO_MAX_3D_TEXTURE_SIZE = 0x3F, NVN_DEVICE_INFO_MAX_CUBE_MAP_TEXTURE_SIZE = 0x40, NVN_DEVICE_INFO_MAX_RECTANGLE_TEXTURE_SIZE = 0x41, NVN_DEVICE_INFO_SUPPORTS_PASSTHROUGH_GEOMETRY_SHADERS = 0x42, NVN_DEVICE_INFO_SUPPORTS_VIEWPORT_SWIZZLE = 0x43, NVN_DEVICE_INFO_SUPPORTS_SPARSE_TILED_PACKAGED_TEXTURES = 0x44, NVN_DEVICE_INFO_SUPPORTS_ADVANCED_BLEND_MODES = 0x45, NVN_DEVICE_INFO_MAX_PRESENT_INTERVAL = 0x46, NVN_DEVICE_INFO_SUPPORTS_DRAW_TEXTURE = 0x47, NVN_DEVICE_INFO_SUPPORTS_TARGET_INDEPENDENT_RASTERIZATION = 0x48, NVN_DEVICE_INFO_SUPPORTS_FRAGMENT_COVERAGE_TO_COLOR = 0x49, NVN_DEVICE_INFO_SUPPORTS_POST_DEPTH_COVERAGE = 0x4A, NVN_DEVICE_INFO_SUPPORTS_IMAGES_USING_TEXTURE_HANDLES = 0x4B, NVN_DEVICE_INFO_SUPPORTS_SAMPLE_LOCATIONS = 0x4C, NVN_DEVICE_INFO_MAX_SAMPLE_LOCATION_TABLE_ENTRIES = 0x4D, NVN_DEVICE_INFO_SHADER_CODE_MEMORY_POOL_PADDING_SIZE = 0x4E, NVN_DEVICE_INFO_MAX_PATCH_SIZE = 0x4F, NVN_DEVICE_INFO_QUEUE_COMMAND_MEMORY_GRANULARITY = 0x50, NVN_DEVICE_INFO_QUEUE_COMMAND_MEMORY_MIN_SIZE = 0x51, NVN_DEVICE_INFO_QUEUE_COMMAND_MEMORY_DEFAULT_SIZE = 0x52, NVN_DEVICE_INFO_QUEUE_COMPUTE_MEMORY_GRANULARITY = 0x53, NVN_DEVICE_INFO_QUEUE_COMPUTE_MEMORY_MIN_SIZE = 0x54, NVN_DEVICE_INFO_QUEUE_COMPUTE_MEMORY_DEFAULT_SIZE = 0x55, NVN_DEVICE_INFO_QUEUE_COMMAND_MEMORY_MIN_FLUSH_THRESHOLD = 0x56, NVN_DEVICE_INFO_SUPPORTS_FRAGMENT_SHADER_INTERLOCK = 0x57, NVN_DEVICE_INFO_MAX_TEXTURES_PER_WINDOW = 0x58, NVN_DEVICE_INFO_MIN_TEXTURES_PER_WINDOW = 0x59, NVN_DEVICE_INFO_SUPPORTS_DEBUG_LAYER = 0x5A, NVN_DEVICE_INFO_QUEUE_CONTROL_MEMORY_MIN_SIZE = 0x5B, NVN_DEVICE_INFO_QUEUE_CONTROL_MEMORY_DEFAULT_SIZE = 0x5C, NVN_DEVICE_INFO_QUEUE_CONTROL_MEMORY_GRANULARITY = 0x5D, NVN_DEVICE_INFO_SEPARATE_TEXTURE_BINDINGS_PER_STAGE = 0x5E, NVN_DEVICE_INFO_SEPARATE_SAMPLER_BINDINGS_PER_STAGE = 0x5F, NVN_DEVICE_INFO_DEBUG_GROUPS_MAX_DOMAIN_ID = 0x60, NVN_DEVICE_INFO_EVENTS_SUPPORT_REDUCTION_OPERATIONS = 0x61, NVN_DEVICE_INFO_LARGE = 0x7FFFFFFF }

enum NVNdeviceFlagBits { NVN_DEVICE_FLAG_DEBUG_ENABLE = 0x1, NVN_DEVICE_FLAG_DEBUG_SKIP_CALLS_ON_ERROR = 0x2, NVN_DEVICE_FLAG_DEBUG_DRAW_VALIDATION = 0x4, NVN_DEVICE_FLAG_DEFERRED_FINALIZE = 0x8, NVN_DEVICE_FLAG_DEBUG_DRAW_VALIDATION_HEAVY = 0x10, NVN_DEVICE_FLAG_DEBUG_ENABLE_LEVEL_0 = 0x20, NVN_DEVICE_FLAG_DEBUG_ENABLE_LEVEL_1 = 0x40, NVN_DEVICE_FLAG_DEBUG_ENABLE_LEVEL_2 = 0x1, NVN_DEVICE_FLAG_DEBUG_ENABLE_LEVEL_3 = 0x4, NVN_DEVICE_FLAG_DEBUG_ENABLE_LEVEL_4 = 0x10, NVN_DEVICE_FLAG_DEFERRED_FIRMWARE_MEMORY_RECLAIM = 0x80, NVN_DEVICE_FLAG_ENABLE_SEPARATE_SAMPLER_TEXTURE_SUPPORT = 0x100, NVN_DEVICE_FLAG_LARGE = 0x7FFFFFFF }

enum NVNclearColorMask { NVN_CLEAR_COLOR_MASK_R_BIT = 0x1, NVN_CLEAR_COLOR_MASK_G_BIT = 0x2, NVN_CLEAR_COLOR_MASK_B_BIT = 0x4, NVN_CLEAR_COLOR_MASK_A_BIT = 0x8, NVN_CLEAR_COLOR_MASK_RGBA = 0xF, NVN_CLEAR_COLOR_MASK_LARGE = 0x7FFFFFFF }

enum NVNdebugCallbackSource { NVN_DEBUG_CALLBACK_SOURCE_API = 0x0, NVN_DEBUG_CALLBACK_SOURCE_LARGE = 0x7FFFFFFF }

enum NVNdebugCallbackType { NVN_DEBUG_CALLBACK_TYPE_API_ERROR = 0x0, NVN_DEBUG_CALLBACK_TYPE_API_WARNING = 0x1, NVN_DEBUG_CALLBACK_TYPE_LARGE = 0x7FFFFFFF }

enum NVNdebugCallbackSeverity { NVN_DEBUG_CALLBACK_SEVERITY_HIGH = 0x0, NVN_DEBUG_CALLBACK_SEVERITY_MEDIUM = 0x1, NVN_DEBUG_CALLBACK_SEVERITY_LOW = 0x2, NVN_DEBUG_CALLBACK_SEVERITY_NOTIFICATION = 0x3, NVN_DEBUG_CALLBACK_SEVERITY_LARGE = 0x7FFFFFFF }

enum NVNwindowOriginMode { NVN_WINDOW_ORIGIN_MODE_LOWER_LEFT = 0x0, NVN_WINDOW_ORIGIN_MODE_UPPER_LEFT = 0x1, NVN_WINDOW_ORIGIN_MODE_LARGE = 0x7FFFFFFF }

enum NVNdepthMode { NVN_DEPTH_MODE_NEAR_IS_MINUS_W = 0x0, NVN_DEPTH_MODE_NEAR_IS_ZERO = 0x1, NVN_DEPTH_MODE_LARGE = 0x7FFFFFFF }

enum NVNformat { NVN_FORMAT_NONE = 0x0, NVN_FORMAT_R8 = 0x1, NVN_FORMAT_R8SN = 0x2, NVN_FORMAT_R8UI = 0x3, NVN_FORMAT_R8I = 0x4, NVN_FORMAT_R16F = 0x5, NVN_FORMAT_R16 = 0x6, NVN_FORMAT_R16SN = 0x7, NVN_FORMAT_R16UI = 0x8, NVN_FORMAT_R16I = 0x9, NVN_FORMAT_R32F = 0xA, NVN_FORMAT_R32UI = 0xB, NVN_FORMAT_R32I = 0xC, NVN_FORMAT_RG8 = 0xD, NVN_FORMAT_RG8SN = 0xE, NVN_FORMAT_RG8UI = 0xF, NVN_FORMAT_RG8I = 0x10, NVN_FORMAT_RG16F = 0x11, NVN_FORMAT_RG16 = 0x12, NVN_FORMAT_RG16SN = 0x13, NVN_FORMAT_RG16UI = 0x14, NVN_FORMAT_RG16I = 0x15, NVN_FORMAT_RG32F = 0x16, NVN_FORMAT_RG32UI = 0x17, NVN_FORMAT_RG32I = 0x18, NVN_FORMAT_RGB8 = 0x19, NVN_FORMAT_RGB8SN = 0x1A, NVN_FORMAT_RGB8UI = 0x1B, NVN_FORMAT_RGB8I = 0x1C, NVN_FORMAT_RGB16F = 0x1D, NVN_FORMAT_RGB16 = 0x1E, NVN_FORMAT_RGB16SN = 0x1F, NVN_FORMAT_RGB16UI = 0x20, NVN_FORMAT_RGB16I = 0x21, NVN_FORMAT_RGB32F = 0x22, NVN_FORMAT_RGB32UI = 0x23, NVN_FORMAT_RGB32I = 0x24, NVN_FORMAT_RGBA8 = 0x25, NVN_FORMAT_RGBA8SN = 0x26, NVN_FORMAT_RGBA8UI = 0x27, NVN_FORMAT_RGBA8I = 0x28, NVN_FORMAT_RGBA16F = 0x29, NVN_FORMAT_RGBA16 = 0x2A, NVN_FORMAT_RGBA16SN = 0x2B, NVN_FORMAT_RGBA16UI = 0x2C, NVN_FORMAT_RGBA16I = 0x2D, NVN_FORMAT_RGBA32F = 0x2E, NVN_FORMAT_RGBA32UI = 0x2F, NVN_FORMAT_RGBA32I = 0x30, NVN_FORMAT_STENCIL8 = 0x31, NVN_FORMAT_DEPTH16 = 0x32, NVN_FORMAT_DEPTH24 = 0x33, NVN_FORMAT_DEPTH32F = 0x34, NVN_FORMAT_DEPTH24_STENCIL8 = 0x35, NVN_FORMAT_DEPTH32F_STENCIL8 = 0x36, NVN_FORMAT_RGBX8_SRGB = 0x37, NVN_FORMAT_RGBA8_SRGB = 0x38, NVN_FORMAT_RGBA4 = 0x39, NVN_FORMAT_RGB5 = 0x3A, NVN_FORMAT_RGB5A1 = 0x3B, NVN_FORMAT_RGB565 = 0x3C, NVN_FORMAT_RGB10A2 = 0x3D, NVN_FORMAT_RGB10A2UI = 0x3E, NVN_FORMAT_R11G11B10F = 0x3F, NVN_FORMAT_RGB9E5F = 0x40, NVN_FORMAT_RGB_DXT1 = 0x41, NVN_FORMAT_RGBA_DXT1 = 0x42, NVN_FORMAT_RGBA_DXT3 = 0x43, NVN_FORMAT_RGBA_DXT5 = 0x44, NVN_FORMAT_RGB_DXT1_SRGB = 0x45, NVN_FORMAT_RGBA_DXT1_SRGB = 0x46, NVN_FORMAT_RGBA_DXT3_SRGB = 0x47, NVN_FORMAT_RGBA_DXT5_SRGB = 0x48, NVN_FORMAT_RGTC1_UNORM = 0x49, NVN_FORMAT_RGTC1_SNORM = 0x4A, NVN_FORMAT_RGTC2_UNORM = 0x4B, NVN_FORMAT_RGTC2_SNORM = 0x4C, NVN_FORMAT_BPTC_UNORM = 0x4D, NVN_FORMAT_BPTC_UNORM_SRGB = 0x4E, NVN_FORMAT_BPTC_SFLOAT = 0x4F, NVN_FORMAT_BPTC_UFLOAT = 0x50, NVN_FORMAT_R8_UI2F = 0x51, NVN_FORMAT_R8_I2F = 0x52, NVN_FORMAT_R16_UI2F = 0x53, NVN_FORMAT_R16_I2F = 0x54, NVN_FORMAT_R32_UI2F = 0x55, NVN_FORMAT_R32_I2F = 0x56, NVN_FORMAT_RG8_UI2F = 0x57, NVN_FORMAT_RG8_I2F = 0x58, NVN_FORMAT_RG16_UI2F = 0x59, NVN_FORMAT_RG16_I2F = 0x5A, NVN_FORMAT_RG32_UI2F = 0x5B, NVN_FORMAT_RG32_I2F = 0x5C, NVN_FORMAT_RGB8_UI2F = 0x5D, NVN_FORMAT_RGB8_I2F = 0x5E, NVN_FORMAT_RGB16_UI2F = 0x5F, NVN_FORMAT_RGB16_I2F = 0x60, NVN_FORMAT_RGB32_UI2F = 0x61, NVN_FORMAT_RGB32_I2F = 0x62, NVN_FORMAT_RGBA8_UI2F = 0x63, NVN_FORMAT_RGBA8_I2F = 0x64, NVN_FORMAT_RGBA16_UI2F = 0x65, NVN_FORMAT_RGBA16_I2F = 0x66, NVN_FORMAT_RGBA32_UI2F = 0x67, NVN_FORMAT_RGBA32_I2F = 0x68, NVN_FORMAT_RGB10A2SN = 0x69, NVN_FORMAT_RGB10A2I = 0x6A, NVN_FORMAT_RGB10A2_UI2F = 0x6B, NVN_FORMAT_RGB10A2_I2F = 0x6C, NVN_FORMAT_RGBX8 = 0x6D, NVN_FORMAT_RGBX8SN = 0x6E, NVN_FORMAT_RGBX8UI = 0x6F, NVN_FORMAT_RGBX8I = 0x70, NVN_FORMAT_RGBX16F = 0x71, NVN_FORMAT_RGBX16 = 0x72, NVN_FORMAT_RGBX16SN = 0x73, NVN_FORMAT_RGBX16UI = 0x74, NVN_FORMAT_RGBX16I = 0x75, NVN_FORMAT_RGBX32F = 0x76, NVN_FORMAT_RGBX32UI = 0x77, NVN_FORMAT_RGBX32I = 0x78, NVN_FORMAT_RGBA_ASTC_4x4 = 0x79, NVN_FORMAT_RGBA_ASTC_5x4 = 0x7A, NVN_FORMAT_RGBA_ASTC_5x5 = 0x7B, NVN_FORMAT_RGBA_ASTC_6x5 = 0x7C, NVN_FORMAT_RGBA_ASTC_6x6 = 0x7D, NVN_FORMAT_RGBA_ASTC_8x5 = 0x7E, NVN_FORMAT_RGBA_ASTC_8x6 = 0x7F, NVN_FORMAT_RGBA_ASTC_8x8 = 0x80, NVN_FORMAT_RGBA_ASTC_10x5 = 0x81, NVN_FORMAT_RGBA_ASTC_10x6 = 0x82, NVN_FORMAT_RGBA_ASTC_10x8 = 0x83, NVN_FORMAT_RGBA_ASTC_10x10 = 0x84, NVN_FORMAT_RGBA_ASTC_12x10 = 0x85, NVN_FORMAT_RGBA_ASTC_12x12 = 0x86, NVN_FORMAT_RGBA_ASTC_4x4_SRGB = 0x87, NVN_FORMAT_RGBA_ASTC_5x4_SRGB = 0x88, NVN_FORMAT_RGBA_ASTC_5x5_SRGB = 0x89, NVN_FORMAT_RGBA_ASTC_6x5_SRGB = 0x8A, NVN_FORMAT_RGBA_ASTC_6x6_SRGB = 0x8B, NVN_FORMAT_RGBA_ASTC_8x5_SRGB = 0x8C, NVN_FORMAT_RGBA_ASTC_8x6_SRGB = 0x8D, NVN_FORMAT_RGBA_ASTC_8x8_SRGB = 0x8E, NVN_FORMAT_RGBA_ASTC_10x5_SRGB = 0x8F, NVN_FORMAT_RGBA_ASTC_10x6_SRGB = 0x90, NVN_FORMAT_RGBA_ASTC_10x8_SRGB = 0x91, NVN_FORMAT_RGBA_ASTC_10x10_SRGB = 0x92, NVN_FORMAT_RGBA_ASTC_12x10_SRGB = 0x93, NVN_FORMAT_RGBA_ASTC_12x12_SRGB = 0x94, NVN_FORMAT_BGR565 = 0x95, NVN_FORMAT_BGR5 = 0x96, NVN_FORMAT_BGR5A1 = 0x97, NVN_FORMAT_A1BGR5 = 0x98, NVN_FORMAT_BGRX8 = 0x99, NVN_FORMAT_BGRA8 = 0x9A, NVN_FORMAT_BGRX8_SRGB = 0x9B, NVN_FORMAT_BGRA8_SRGB = 0x9C, NVN_FORMAT_LARGE = 0x7FFFFFFF }

enum NVNdebugObjectType { NVN_DEBUG_OBJECT_TYPE_WINDOW = 0x0, NVN_DEBUG_OBJECT_TYPE_QUEUE = 0x1, NVN_DEBUG_OBJECT_TYPE_COMMAND_BUFFER = 0x2, NVN_DEBUG_OBJECT_TYPE_MEMORY_POOL = 0x3, NVN_DEBUG_OBJECT_TYPE_SYNC = 0x7, NVN_DEBUG_OBJECT_TYPE_PROGRAM = 0x9, NVN_DEBUG_OBJECT_TYPE_TEXTURE_POOL = 0xA, NVN_DEBUG_OBJECT_TYPE_SAMPLER_POOL = 0xB, NVN_DEBUG_OBJECT_TYPE_LARGE = 0x7FFFFFFF }

enum NVNqueueGetErrorResult { NVN_QUEUE_GET_ERROR_RESULT_GPU_NO_ERROR = 0x0, NVN_QUEUE_GET_ERROR_RESULT_GPU_ERROR_UNKNOWN = 0x1, NVN_QUEUE_GET_ERROR_RESULT_GPU_ERROR_MMU_FAULT = 0x2, NVN_QUEUE_GET_ERROR_RESULT_GPU_ERROR_PBDMA_EXCEPTION = 0x3, NVN_QUEUE_GET_ERROR_RESULT_GPU_ERROR_ENGINE_EXCEPTION = 0x4, NVN_QUEUE_GET_ERROR_RESULT_GPU_ERROR_TIMEOUT = 0x5, NVN_QUEUE_GET_ERROR_RESULT_LARGE = 0x7FFFFFFF }

enum NVNqueueBuilderFlags { NVN_QUEUE_BUILDER_FLAGS_NONE = 0x0, NVN_QUEUE_BUILDER_FLAGS_NO_FRAGMENT_INTERLOCK = 0x1, NVN_QUEUE_BUILDER_FLAGS_NO_ZCULL = 0x2, NVN_QUEUE_BUILDER_FLAGS_LARGE = 0x7FFFFFFF }

enum NVNqueueAcquireTextureResult { NVN_QUEUE_ACQUIRE_TEXTURE_RESULT_SUCCESS = 0x0, NVN_QUEUE_ACQUIRE_TEXTURE_RESULT_NATIVE_ERROR = 0x1, NVN_QUEUE_ACQUIRE_TEXTURE_RESULT_LARGE = 0x7FFFFFFF }

enum NVNwindowAcquireTextureResult { NVN_WINDOW_ACQUIRE_TEXTURE_RESULT_SUCCESS = 0x0, NVN_WINDOW_ACQUIRE_TEXTURE_RESULT_NATIVE_ERROR = 0x1, NVN_WINDOW_ACQUIRE_TEXTURE_RESULT_LARGE = 0x7FFFFFFF }

enum NVNmemoryPoolFlags { NVN_MEMORY_POOL_FLAGS_CPU_NO_ACCESS = 0x1, NVN_MEMORY_POOL_FLAGS_CPU_UNCACHED = 0x2, NVN_MEMORY_POOL_FLAGS_CPU_CACHED = 0x4, NVN_MEMORY_POOL_FLAGS_GPU_NO_ACCESS = 0x8, NVN_MEMORY_POOL_FLAGS_GPU_UNCACHED = 0x10, NVN_MEMORY_POOL_FLAGS_GPU_CACHED = 0x20, NVN_MEMORY_POOL_FLAGS_SHADER_CODE = 0x40, NVN_MEMORY_POOL_FLAGS_COMPRESSIBLE = 0x80, NVN_MEMORY_POOL_FLAGS_PHYSICAL = 0x100, NVN_MEMORY_POOL_FLAGS_VIRTUAL = 0x200, NVN_MEMORY_POOL_FLAGS_LARGE = 0x7FFFFFFF }

enum NVNtextureSwizzle { NVN_TEXTURE_SWIZZLE_ZERO = 0x0, NVN_TEXTURE_SWIZZLE_ONE = 0x1, NVN_TEXTURE_SWIZZLE_R = 0x2, NVN_TEXTURE_SWIZZLE_G = 0x3, NVN_TEXTURE_SWIZZLE_B = 0x4, NVN_TEXTURE_SWIZZLE_A = 0x5, NVN_TEXTURE_SWIZZLE_LARGE = 0x7FFFFFFF }

enum NVNshaderStage { NVN_SHADER_STAGE_VERTEX = 0x0, NVN_SHADER_STAGE_FRAGMENT = 0x1, NVN_SHADER_STAGE_GEOMETRY = 0x2, NVN_SHADER_STAGE_TESS_CONTROL = 0x3, NVN_SHADER_STAGE_TESS_EVALUATION = 0x4, NVN_SHADER_STAGE_COMPUTE = 0x5, NVN_SHADER_STAGE_LARGE = 0x7FFFFFFF }

enum NVNshaderStageBits { NVN_SHADER_STAGE_VERTEX_BIT = 0x1, NVN_SHADER_STAGE_FRAGMENT_BIT = 0x2, NVN_SHADER_STAGE_GEOMETRY_BIT = 0x4, NVN_SHADER_STAGE_TESS_CONTROL_BIT = 0x8, NVN_SHADER_STAGE_TESS_EVALUATION_BIT = 0x10, NVN_SHADER_STAGE_COMPUTE_BIT = 0x20, NVN_SHADER_STAGE_ALL_GRAPHICS_BITS = 31, NVN_SHADER_STAGE_BITS_LARGE = 0x7FFFFFFF }

enum NVNeventWaitMode { NVN_EVENT_WAIT_MODE_EQUAL = 0x0, NVN_EVENT_WAIT_MODE_GEQUAL_WRAP = 0x1, NVN_EVENT_WAIT_MODE_LARGE = 0x7FFFFFFF }

enum NVNeventSignalMode { NVN_EVENT_SIGNAL_MODE_WRITE = 0x0, NVN_EVENT_SIGNAL_MODE_ADD = 0x1, NVN_EVENT_SIGNAL_MODE_LARGE = 0x7FFFFFFF }

enum NVNeventSignalLocation { NVN_EVENT_SIGNAL_LOCATION_TOP = 0x0, NVN_EVENT_SIGNAL_LOCATION_VERTEX_PIPE = 0x1, NVN_EVENT_SIGNAL_LOCATION_BOTTOM = 0x2, NVN_EVENT_SIGNAL_LOCATION_LARGE = 0x7FFFFFFF }

enum NVNsyncCondition { NVN_SYNC_CONDITION_ALL_GPU_COMMANDS_COMPLETE = 0x0, NVN_SYNC_CONDITION_GRAPHICS_WORLD_SPACE_COMPLETE = 0x1, NVN_SYNC_CONDITION_LARGE = 0x7FFFFFFF }

enum NVNcounterType { NVN_COUNTER_TYPE_TIMESTAMP = 0x0, NVN_COUNTER_TYPE_SAMPLES_PASSED = 0x1, NVN_COUNTER_TYPE_INPUT_VERTICES = 0x2, NVN_COUNTER_TYPE_INPUT_PRIMITIVES = 0x3, NVN_COUNTER_TYPE_VERTEX_SHADER_INVOCATIONS = 0x4, NVN_COUNTER_TYPE_TESS_CONTROL_SHADER_INVOCATIONS = 0x5, NVN_COUNTER_TYPE_TESS_EVALUATION_SHADER_INVOCATIONS = 0x6, NVN_COUNTER_TYPE_GEOMETRY_SHADER_INVOCATIONS = 0x7, NVN_COUNTER_TYPE_FRAGMENT_SHADER_INVOCATIONS = 0x8, NVN_COUNTER_TYPE_TESS_EVALUATION_SHADER_PRIMITIVES = 0x9, NVN_COUNTER_TYPE_GEOMETRY_SHADER_PRIMITIVES = 0xA, NVN_COUNTER_TYPE_CLIPPER_INPUT_PRIMITIVES = 0xB, NVN_COUNTER_TYPE_CLIPPER_OUTPUT_PRIMITIVES = 0xC, NVN_COUNTER_TYPE_PRIMITIVES_GENERATED = 0xD, NVN_COUNTER_TYPE_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0xE, NVN_COUNTER_TYPE_ZCULL_STATS = 0xF, NVN_COUNTER_TYPE_TIMESTAMP_TOP = 0x10, NVN_COUNTER_TYPE_LARGE = 0x7FFFFFFF }

enum NVNface { NVN_FACE_NONE = 0x0, NVN_FACE_FRONT = 0x1, NVN_FACE_BACK = 0x2, NVN_FACE_FRONT_AND_BACK = 0x3, NVN_FACE_LARGE = 0x7FFFFFFF }

enum NVNcommandBufferMemoryEvent { NVN_COMMAND_BUFFER_MEMORY_EVENT_OUT_OF_COMMAND_MEMORY = 0x0, NVN_COMMAND_BUFFER_MEMORY_EVENT_OUT_OF_CONTROL_MEMORY = 0x1, NVN_COMMAND_BUFFER_MEMORY_EVENT_LARGE = 0x7FFFFFFF }

enum NVNdrawPrimitive { NVN_DRAW_PRIMITIVE_POINTS = 0x0, NVN_DRAW_PRIMITIVE_LINES = 0x1, NVN_DRAW_PRIMITIVE_LINE_LOOP = 0x2, NVN_DRAW_PRIMITIVE_LINE_STRIP = 0x3, NVN_DRAW_PRIMITIVE_TRIANGLES = 0x4, NVN_DRAW_PRIMITIVE_TRIANGLE_STRIP = 0x5, NVN_DRAW_PRIMITIVE_TRIANGLE_FAN = 0x6, NVN_DRAW_PRIMITIVE_QUADS = 0x7, NVN_DRAW_PRIMITIVE_QUAD_STRIP = 0x8, NVN_DRAW_PRIMITIVE_POLYGON = 0x9, NVN_DRAW_PRIMITIVE_LINES_ADJACENCY = 0xA, NVN_DRAW_PRIMITIVE_LINE_STRIP_ADJACENCY = 0xB, NVN_DRAW_PRIMITIVE_TRIANGLES_ADJACENCY = 0xC, NVN_DRAW_PRIMITIVE_TRIANGLE_STRIP_ADJACENCY = 0xD, NVN_DRAW_PRIMITIVE_PATCHES = 0xE, NVN_DRAW_PRIMITIVE_LARGE = 0x7FFFFFFF }

enum NVNindexType { NVN_INDEX_TYPE_UNSIGNED_BYTE = 0x0, NVN_INDEX_TYPE_UNSIGNED_SHORT = 0x1, NVN_INDEX_TYPE_UNSIGNED_INT = 0x2, NVN_INDEX_TYPE_LARGE = 0x7FFFFFFF }

enum NVNtextureFlags { NVN_TEXTURE_FLAGS_DISPLAY = 0x1, NVN_TEXTURE_FLAGS_VIDEO_DECODE = 0x2, NVN_TEXTURE_FLAGS_IMAGE = 0x4, NVN_TEXTURE_FLAGS_COMPRESSIBLE = 0x8, NVN_TEXTURE_FLAGS_LINEAR = 0x10, NVN_TEXTURE_FLAGS_SPARSE = 0x20, NVN_TEXTURE_FLAGS_LINEAR_RENDER_TARGET = 0x40, NVN_TEXTURE_FLAGS_ADAPTIVE_ZCULL = 0x80, NVN_TEXTURE_FLAGS_DEPTH16_PREFER_FAST_CLEAR = 0x100, NVN_TEXTURE_FLAGS_MINIMAL_LAYOUT = 0x200, NVN_TEXTURE_FLAGS_ZCULL_SUPPORT_STENCIL = 0x400, NVN_TEXTURE_FLAGS_LARGE = 0x7FFFFFFF }

enum NVNbarrierBits { NVN_BARRIER_ORDER_PRIMITIVES_BIT = 0x1, NVN_BARRIER_ORDER_FRAGMENTS_BIT = 0x2, NVN_BARRIER_ORDER_FRAGMENTS_TILED_BIT = 0x4, NVN_BARRIER_ORDER_INDIRECT_DATA_BIT = 0x8, NVN_BARRIER_INVALIDATE_TEXTURE_BIT = 0x10, NVN_BARRIER_INVALIDATE_SHADER_BIT = 0x20, NVN_BARRIER_INVALIDATE_TEXTURE_DESCRIPTOR_BIT = 0x40, NVN_BARRIER_INVALIDATE_ZCULL_BIT = 0x80, NVN_BARRIER_BITS_LARGE = 0x7FFFFFFF }

enum NVNtextureTarget { NVN_TEXTURE_TARGET_1D = 0x0, NVN_TEXTURE_TARGET_2D = 0x1, NVN_TEXTURE_TARGET_3D = 0x2, NVN_TEXTURE_TARGET_1D_ARRAY = 0x3, NVN_TEXTURE_TARGET_2D_ARRAY = 0x4, NVN_TEXTURE_TARGET_2D_MULTISAMPLE = 0x5, NVN_TEXTURE_TARGET_2D_MULTISAMPLE_ARRAY = 0x6, NVN_TEXTURE_TARGET_RECTANGLE = 0x7, NVN_TEXTURE_TARGET_CUBEMAP = 0x8, NVN_TEXTURE_TARGET_CUBEMAP_ARRAY = 0x9, NVN_TEXTURE_TARGET_BUFFER = 0xA, NVN_TEXTURE_TARGET_LARGE = 0x7FFFFFFF }

enum NVNtextureDepthStencilMode { NVN_TEXTURE_DEPTH_STENCIL_MODE_DEPTH = 0x0, NVN_TEXTURE_DEPTH_STENCIL_MODE_STENCIL = 0x1, NVN_TEXTURE_DEPTH_STENCIL_MODE_LARGE = 0x7FFFFFFF }

enum NVNlogicOp { NVN_LOGIC_OP_CLEAR = 0x0, NVN_LOGIC_OP_AND = 0x1, NVN_LOGIC_OP_AND_REVERSE = 0x2, NVN_LOGIC_OP_COPY = 0x3, NVN_LOGIC_OP_AND_INVERTED = 0x4, NVN_LOGIC_OP_NOOP = 0x5, NVN_LOGIC_OP_XOR = 0x6, NVN_LOGIC_OP_OR = 0x7, NVN_LOGIC_OP_NOR = 0x8, NVN_LOGIC_OP_EQUIV = 0x9, NVN_LOGIC_OP_INVERT = 0xA, NVN_LOGIC_OP_OR_REVERSE = 0xB, NVN_LOGIC_OP_COPY_INVERTED = 0xC, NVN_LOGIC_OP_OR_INVERTED = 0xD, NVN_LOGIC_OP_NAND = 0xE, NVN_LOGIC_OP_SET = 0xF, NVN_LOGIC_OP_LARGE = 0x7FFFFFFF }

enum NVNalphaFunc { NVN_ALPHA_FUNC_NEVER = 0x1, NVN_ALPHA_FUNC_LESS = 0x2, NVN_ALPHA_FUNC_EQUAL = 0x3, NVN_ALPHA_FUNC_LEQUAL = 0x4, NVN_ALPHA_FUNC_GREATER = 0x5, NVN_ALPHA_FUNC_NOTEQUAL = 0x6, NVN_ALPHA_FUNC_GEQUAL = 0x7, NVN_ALPHA_FUNC_ALWAYS = 0x8, NVN_ALPHA_FUNC_LARGE = 0x7FFFFFFF }

enum NVNblendAdvancedMode { NVN_BLEND_ADVANCED_MODE_NONE = 0x0, NVN_BLEND_ADVANCED_MODE_ZERO = 0x5, NVN_BLEND_ADVANCED_MODE_SRC = 0x6, NVN_BLEND_ADVANCED_MODE_DST = 0x7, NVN_BLEND_ADVANCED_MODE_SRC_OVER = 0x8, NVN_BLEND_ADVANCED_MODE_DST_OVER = 0x9, NVN_BLEND_ADVANCED_MODE_SRC_IN = 0xA, NVN_BLEND_ADVANCED_MODE_DST_IN = 0xB, NVN_BLEND_ADVANCED_MODE_SRC_OUT = 0xC, NVN_BLEND_ADVANCED_MODE_DST_OUT = 0xD, NVN_BLEND_ADVANCED_MODE_SRC_ATOP = 0xE, NVN_BLEND_ADVANCED_MODE_DST_ATOP = 0xF, NVN_BLEND_ADVANCED_MODE_XOR = 0x10, NVN_BLEND_ADVANCED_MODE_PLUS = 0x11, NVN_BLEND_ADVANCED_MODE_PLUS_CLAMPED = 0x12, NVN_BLEND_ADVANCED_MODE_PLUS_CLAMPED_ALPHA = 0x13, NVN_BLEND_ADVANCED_MODE_PLUS_DARKER = 0x14, NVN_BLEND_ADVANCED_MODE_MULTIPLY = 0x15, NVN_BLEND_ADVANCED_MODE_SCREEN = 0x16, NVN_BLEND_ADVANCED_MODE_OVERLAY = 0x17, NVN_BLEND_ADVANCED_MODE_DARKEN = 0x18, NVN_BLEND_ADVANCED_MODE_LIGHTEN = 0x19, NVN_BLEND_ADVANCED_MODE_COLORDODGE = 0x1A, NVN_BLEND_ADVANCED_MODE_COLORBURN = 0x1B, NVN_BLEND_ADVANCED_MODE_HARDLIGHT = 0x1C, NVN_BLEND_ADVANCED_MODE_SOFTLIGHT = 0x1D, NVN_BLEND_ADVANCED_MODE_DIFFERENCE = 0x1E, NVN_BLEND_ADVANCED_MODE_MINUS = 0x1F, NVN_BLEND_ADVANCED_MODE_MINUS_CLAMPED = 0x20, NVN_BLEND_ADVANCED_MODE_EXCLUSION = 0x21, NVN_BLEND_ADVANCED_MODE_CONTRAST = 0x22, NVN_BLEND_ADVANCED_MODE_INVERT = 0x23, NVN_BLEND_ADVANCED_MODE_INVERT_RGB = 0x24, NVN_BLEND_ADVANCED_MODE_INVERT_OVG = 0x25, NVN_BLEND_ADVANCED_MODE_LINEARDODGE = 0x26, NVN_BLEND_ADVANCED_MODE_LINEARBURN = 0x27, NVN_BLEND_ADVANCED_MODE_VIVIDLIGHT = 0x28, NVN_BLEND_ADVANCED_MODE_LINEARLIGHT = 0x29, NVN_BLEND_ADVANCED_MODE_PINLIGHT = 0x2A, NVN_BLEND_ADVANCED_MODE_HARDMIX = 0x2B, NVN_BLEND_ADVANCED_MODE_RED = 0x2C, NVN_BLEND_ADVANCED_MODE_GREEN = 0x2D, NVN_BLEND_ADVANCED_MODE_BLUE = 0x2E, NVN_BLEND_ADVANCED_MODE_HSL_HUE = 0x2F, NVN_BLEND_ADVANCED_MODE_HSL_SATURATION = 0x30, NVN_BLEND_ADVANCED_MODE_HSL_COLOR = 0x31, NVN_BLEND_ADVANCED_MODE_HSL_LUMINOSITY = 0x32, NVN_BLEND_ADVANCED_MODE_LARGE = 0x7FFFFFFF }

enum NVNminFilter { NVN_MIN_FILTER_NEAREST = 0x0, NVN_MIN_FILTER_LINEAR = 0x1, NVN_MIN_FILTER_NEAREST_MIPMAP_NEAREST = 0x2, NVN_MIN_FILTER_LINEAR_MIPMAP_NEAREST = 0x3, NVN_MIN_FILTER_NEAREST_MIPMAP_LINEAR = 0x4, NVN_MIN_FILTER_LINEAR_MIPMAP_LINEAR = 0x5, NVN_MIN_FILTER_LARGE = 0x7FFFFFFF }

enum NVNmagFilter { NVN_MAG_FILTER_NEAREST = 0x0, NVN_MAG_FILTER_LINEAR = 0x1, NVN_MAG_FILTER_LARGE = 0x7FFFFFFF }

enum NVNwrapMode { NVN_WRAP_MODE_CLAMP = 0x0, NVN_WRAP_MODE_REPEAT = 0x1, NVN_WRAP_MODE_MIRROR_CLAMP = 0x2, NVN_WRAP_MODE_MIRROR_CLAMP_TO_EDGE = 0x3, NVN_WRAP_MODE_MIRROR_CLAMP_TO_BORDER = 0x4, NVN_WRAP_MODE_CLAMP_TO_BORDER = 0x5, NVN_WRAP_MODE_MIRRORED_REPEAT = 0x6, NVN_WRAP_MODE_CLAMP_TO_EDGE = 0x7, NVN_WRAP_MODE_LARGE = 0x7FFFFFFF }

enum NVNcompareMode { NVN_COMPARE_MODE_NONE = 0x0, NVN_COMPARE_MODE_COMPARE_R_TO_TEXTURE = 0x1, NVN_COMPARE_MODE_LARGE = 0x7FFFFFFF }

enum NVNcompareFunc { NVN_COMPARE_FUNC_NEVER = 0x1, NVN_COMPARE_FUNC_LESS = 0x2, NVN_COMPARE_FUNC_EQUAL = 0x3, NVN_COMPARE_FUNC_LEQUAL = 0x4, NVN_COMPARE_FUNC_GREATER = 0x5, NVN_COMPARE_FUNC_NOTEQUAL = 0x6, NVN_COMPARE_FUNC_GEQUAL = 0x7, NVN_COMPARE_FUNC_ALWAYS = 0x8, NVN_COMPARE_FUNC_LARGE = 0x7FFFFFFF }

enum NVNsamplerReduction { NVN_SAMPLER_REDUCTION_AVERAGE = 0x0, NVN_SAMPLER_REDUCTION_MIN = 0x1, NVN_SAMPLER_REDUCTION_MAX = 0x2, NVN_SAMPLER_REDUCTION_LARGE = 0x7FFFFFFF }

enum NVNblendFunc { NVN_BLEND_FUNC_ZERO = 0x1, NVN_BLEND_FUNC_ONE = 0x2, NVN_BLEND_FUNC_SRC_COLOR = 0x3, NVN_BLEND_FUNC_ONE_MINUS_SRC_COLOR = 0x4, NVN_BLEND_FUNC_SRC_ALPHA = 0x5, NVN_BLEND_FUNC_ONE_MINUS_SRC_ALPHA = 0x6, NVN_BLEND_FUNC_DST_ALPHA = 0x7, NVN_BLEND_FUNC_ONE_MINUS_DST_ALPHA = 0x8, NVN_BLEND_FUNC_DST_COLOR = 0x9, NVN_BLEND_FUNC_ONE_MINUS_DST_COLOR = 0xA, NVN_BLEND_FUNC_SRC_ALPHA_SATURATE = 0xB, NVN_BLEND_FUNC_SRC1_COLOR = 0x10, NVN_BLEND_FUNC_ONE_MINUS_SRC1_COLOR = 0x11, NVN_BLEND_FUNC_SRC1_ALPHA = 0x12, NVN_BLEND_FUNC_ONE_MINUS_SRC1_ALPHA = 0x13, NVN_BLEND_FUNC_CONSTANT_COLOR = 0x61, NVN_BLEND_FUNC_ONE_MINUS_CONSTANT_COLOR = 0x62, NVN_BLEND_FUNC_CONSTANT_ALPHA = 0x63, NVN_BLEND_FUNC_ONE_MINUS_CONSTANT_ALPHA = 0x64, NVN_BLEND_FUNC_LARGE = 0x7FFFFFFF }

enum NVNblendEquation { NVN_BLEND_EQUATION_ADD = 0x1, NVN_BLEND_EQUATION_SUB = 0x2, NVN_BLEND_EQUATION_REVERSE_SUB = 0x3, NVN_BLEND_EQUATION_MIN = 0x4, NVN_BLEND_EQUATION_MAX = 0x5, NVN_BLEND_EQUATION_LARGE = 0x7FFFFFFF }

enum NVNblendAdvancedOverlap { NVN_BLEND_ADVANCED_OVERLAP_UNCORRELATED = 0x0, NVN_BLEND_ADVANCED_OVERLAP_DISJOINT = 0x1, NVN_BLEND_ADVANCED_OVERLAP_CONJOINT = 0x2, NVN_BLEND_ADVANCED_OVERLAP_LARGE = 0x7FFFFFFF }

enum NVNcoverageModulationMode { NVN_COVERAGE_MODULATION_MODE_NONE = 0x0, NVN_COVERAGE_MODULATION_MODE_RGB = 0x1, NVN_COVERAGE_MODULATION_MODE_ALPHA = 0x2, NVN_COVERAGE_MODULATION_MODE_RGBA = 0x3, NVN_COVERAGE_MODULATION_MODE_LARGE = 0x7FFFFFFF }

enum NVNdepthFunc { NVN_DEPTH_FUNC_NEVER = 0x1, NVN_DEPTH_FUNC_LESS = 0x2, NVN_DEPTH_FUNC_EQUAL = 0x3, NVN_DEPTH_FUNC_LEQUAL = 0x4, NVN_DEPTH_FUNC_GREATER = 0x5, NVN_DEPTH_FUNC_NOTEQUAL = 0x6, NVN_DEPTH_FUNC_GEQUAL = 0x7, NVN_DEPTH_FUNC_ALWAYS = 0x8, NVN_DEPTH_FUNC_LARGE = 0x7FFFFFFF }

enum NVNstencilFunc { NVN_STENCIL_FUNC_NEVER = 0x1, NVN_STENCIL_FUNC_LESS = 0x2, NVN_STENCIL_FUNC_EQUAL = 0x3, NVN_STENCIL_FUNC_LEQUAL = 0x4, NVN_STENCIL_FUNC_GREATER = 0x5, NVN_STENCIL_FUNC_NOTEQUAL = 0x6, NVN_STENCIL_FUNC_GEQUAL = 0x7, NVN_STENCIL_FUNC_ALWAYS = 0x8, NVN_STENCIL_FUNC_LARGE = 0x7FFFFFFF }

enum NVNstencilOp { NVN_STENCIL_OP_KEEP = 0x1, NVN_STENCIL_OP_ZERO = 0x2, NVN_STENCIL_OP_REPLACE = 0x3, NVN_STENCIL_OP_INCR = 0x4, NVN_STENCIL_OP_DECR = 0x5, NVN_STENCIL_OP_INVERT = 0x6, NVN_STENCIL_OP_INCR_WRAP = 0x7, NVN_STENCIL_OP_DECR_WRAP = 0x8, NVN_STENCIL_OP_LARGE = 0x7FFFFFFF }

enum NVNfrontFace { NVN_FRONT_FACE_CW = 0x0, NVN_FRONT_FACE_CCW = 0x1, NVN_FRONT_FACE_LARGE = 0x7FFFFFFF }

enum NVNsyncWaitResult { NVN_SYNC_WAIT_RESULT_ALREADY_SIGNALED = 0x0, NVN_SYNC_WAIT_RESULT_CONDITION_SATISFIED = 0x1, NVN_SYNC_WAIT_RESULT_TIMEOUT_EXPIRED = 0x2, NVN_SYNC_WAIT_RESULT_FAILED = 0x3, NVN_SYNC_WAIT_RESULT_LARGE = 0x7FFFFFFF }

enum NVNpolygonOffsetEnable { NVN_POLYGON_OFFSET_ENABLE_NONE = 0x0, NVN_POLYGON_OFFSET_ENABLE_POINT = 0x1, NVN_POLYGON_OFFSET_ENABLE_LINE = 0x2, NVN_POLYGON_OFFSET_ENABLE_FILL = 0x4, NVN_POLYGON_OFFSET_ENABLE_LARGE = 0x7FFFFFFF }

enum NVNpolygonMode { NVN_POLYGON_MODE_POINT = 0x0, NVN_POLYGON_MODE_LINE = 0x1, NVN_POLYGON_MODE_FILL = 0x2, NVN_POLYGON_MODE_LARGE = 0x7FFFFFFF }

enum NVNviewportSwizzle { NVN_VIEWPORT_SWIZZLE_POSITIVE_X = 0x0, NVN_VIEWPORT_SWIZZLE_NEGATIVE_X = 0x1, NVN_VIEWPORT_SWIZZLE_POSITIVE_Y = 0x2, NVN_VIEWPORT_SWIZZLE_NEGATIVE_Y = 0x3, NVN_VIEWPORT_SWIZZLE_POSITIVE_Z = 0x4, NVN_VIEWPORT_SWIZZLE_NEGATIVE_Z = 0x5, NVN_VIEWPORT_SWIZZLE_POSITIVE_W = 0x6, NVN_VIEWPORT_SWIZZLE_NEGATIVE_W = 0x7, NVN_VIEWPORT_SWIZZLE_LARGE = 0x7FFFFFFF }

enum NVNtiledCacheAction { NVN_TILED_CACHE_ACTION_ENABLE = 0x1, NVN_TILED_CACHE_ACTION_DISABLE = 0x2, NVN_TILED_CACHE_ACTION_FLUSH = 0x3, NVN_TILED_CACHE_ACTION_FLUSH_NO_TILING = 0x4, NVN_TILED_CACHE_ACTION_ENABLE_RENDER_TARGET_BINNING = 0x5, NVN_TILED_CACHE_ACTION_DISABLE_RENDER_TARGET_BINNING = 0x6, NVN_TILED_CACHE_ACTION_LARGE = 0x7FFFFFFF }

enum NVNconditionalRenderMode { NVN_CONDITIONAL_RENDER_MODE_RENDER_IF_EQUAL = 0x0, NVN_CONDITIONAL_RENDER_MODE_RENDER_IF_NOT_EQUAL = 0x1, NVN_CONDITIONAL_RENDER_MODE_LARGE = 0x7FFFFFFF }

enum NVNcopyFlags { NVN_COPY_FLAGS_NONE = 0x0, NVN_COPY_FLAGS_LINEAR_FILTER_BIT = 0x1, NVN_COPY_FLAGS_ENGINE_2D_BIT = 0x2, NVN_COPY_FLAGS_MIRROR_X_BIT = 0x4, NVN_COPY_FLAGS_MIRROR_Y_BIT = 0x8, NVN_COPY_FLAGS_MIRROR_Z_BIT = 0x10, NVN_COPY_FLAGS_LARGE = 0x7FFFFFFF }

Typedefs

using NVNboolean = uint8_t

using NVNtextureHandle = uint64_t

using NVNimageHandle = uint64_t

using NVNcommandHandle = uint64_t

using NVNbufferAddress = uint64_t

using NVNtextureAddress = uint64_t

using NVNdebugDomainId = int

using NVNstorageClass = int

using NVNsubroutineLinkageMapPtr = void*

using NVNnativeWindow = void*

using PFNNVNGENERICFUNCPTRPROC = void(*)(void)

using PFNNVNBOOTSTRAPLOADERPROC = PFNNVNGENERICFUNCPTRPROC(*)(const char*)

using PFNNVNCOMMANDBUFFERMEMORYCALLBACKPROC = void(*)(NVNcommandBuffer*, NVNcommandBufferMemoryEvent, size_t, void*)

using PFNNVNDEBUGCALLBACKPROC = void(*)(NVNdebugCallbackSource source, NVNdebugCallbackType type, int id, NVNdebugCallbackSeverity severity, const unsigned char*message, void*user)

using PFNNVNWALKDEBUGDATABASECALLBACKPROC = void(*)(void*, void*)

using PFNNVNDEVICEBUILDERSETDEFAULTSPROC = void(*)(NVNdeviceBuilder*)

using PFNNVNDEVICEBUILDERSETFLAGSPROC = void(*)(NVNdeviceBuilder*, int)

using PFNNVNDEVICEINITIALIZEPROC = NVNboolean(*)(NVNdevice*, const NVNdeviceBuilder*)

using PFNNVNDEVICEFINALIZEPROC = void(*)(NVNdevice*)

using PFNNVNDEVICESETDEBUGLABELPROC = void(*)(NVNdevice*, const char*)

using PFNNVNDEVICEGETPROCADDRESSPROC = PFNNVNGENERICFUNCPTRPROC(*)(const NVNdevice*, const char*)

using PFNNVNDEVICEGETINTEGERPROC = void(*)(const NVNdevice*, NVNdeviceInfo, int*)

using PFNNVNDEVICEGETCURRENTTIMESTAMPINNANOSECONDSPROC = uint64_t(*)(const NVNdevice*)

using PFNNVNDEVICESETINTERMEDIATESHADERCACHEPROC = void(*)(NVNdevice*, int)

using PFNNVNDEVICEGETTEXTUREHANDLEPROC = NVNtextureHandle(*)(const NVNdevice*, int, int)

using PFNNVNDEVICEGETTEXELFETCHHANDLEPROC = NVNtextureHandle(*)(const NVNdevice*, int)

using PFNNVNDEVICEGETIMAGEHANDLEPROC = NVNimageHandle(*)(const NVNdevice*, int)

using PFNNVNDEVICEINSTALLDEBUGCALLBACKPROC = void(*)(NVNdevice*, const PFNNVNDEBUGCALLBACKPROC, void*, NVNboolean)

using PFNNVNDEVICEGENERATEDEBUGDOMAINIDPROC = NVNdebugDomainId(*)(const NVNdevice*, const char*)

using PFNNVNDEVICESETWINDOWORIGINMODEPROC = void(*)(NVNdevice*, NVNwindowOriginMode)

using PFNNVNDEVICESETDEPTHMODEPROC = void(*)(NVNdevice*, NVNdepthMode)

using PFNNVNDEVICEREGISTERFASTCLEARCOLORPROC = NVNboolean(*)(NVNdevice*, const float*, NVNformat)

using PFNNVNDEVICEREGISTERFASTCLEARCOLORIPROC = NVNboolean(*)(NVNdevice*, const int*, NVNformat)

using PFNNVNDEVICEREGISTERFASTCLEARCOLORUIPROC = NVNboolean(*)(NVNdevice*, const uint32_t*, NVNformat)

using PFNNVNDEVICEREGISTERFASTCLEARDEPTHPROC = NVNboolean(*)(NVNdevice*, float)

using PFNNVNDEVICEGETWINDOWORIGINMODEPROC = NVNwindowOriginMode(*)(const NVNdevice*)

using PFNNVNDEVICEGETDEPTHMODEPROC = NVNdepthMode(*)(const NVNdevice*)

using PFNNVNDEVICEGETTIMESTAMPINNANOSECONDSPROC = uint64_t(*)(const NVNdevice*, const NVNcounterData*)

using PFNNVNDEVICEAPPLYDEFERREDFINALIZESPROC = void(*)(NVNdevice*, int)

using PFNNVNDEVICEFINALIZECOMMANDHANDLEPROC = void(*)(NVNdevice*, NVNcommandHandle)

using PFNNVNDEVICEWALKDEBUGDATABASEPROC = void(*)(const NVNdevice*, NVNdebugObjectType, PFNNVNWALKDEBUGDATABASECALLBACKPROC, void*)

using PFNNVNDEVICEGETSEPARATETEXTUREHANDLEPROC = NVNseparateTextureHandle(*)(const NVNdevice*, int)

using PFNNVNDEVICEGETSEPARATESAMPLERHANDLEPROC = NVNseparateSamplerHandle(*)(const NVNdevice*, int)

using PFNNVNDEVICEISEXTERNALDEBUGGERATTACHEDPROC = NVNboolean(*)(const NVNdevice*)

using PFNNVNQUEUEGETERRORPROC = NVNqueueGetErrorResult(*)(NVNqueue*, NVNqueueErrorInfo*)

using PFNNVNQUEUEGETTOTALCOMMANDMEMORYUSEDPROC = size_t(*)(NVNqueue*)

using PFNNVNQUEUEGETTOTALCONTROLMEMORYUSEDPROC = size_t(*)(NVNqueue*)

using PFNNVNQUEUEGETTOTALCOMPUTEMEMORYUSEDPROC = size_t(*)(NVNqueue*)

using PFNNVNQUEUERESETMEMORYUSAGECOUNTSPROC = void(*)(NVNqueue*)

using PFNNVNQUEUEBUILDERSETDEVICEPROC = void(*)(NVNqueueBuilder*, NVNdevice*)

using PFNNVNQUEUEBUILDERSETDEFAULTSPROC = void(*)(NVNqueueBuilder*)

using PFNNVNQUEUEBUILDERSETFLAGSPROC = void(*)(NVNqueueBuilder*, int)

using PFNNVNQUEUEBUILDERSETCOMMANDMEMORYSIZEPROC = void(*)(NVNqueueBuilder*, size_t)

using PFNNVNQUEUEBUILDERSETCOMPUTEMEMORYSIZEPROC = void(*)(NVNqueueBuilder*, size_t)

using PFNNVNQUEUEBUILDERSETCONTROLMEMORYSIZEPROC = void(*)(NVNqueueBuilder*, size_t)

using PFNNVNQUEUEBUILDERGETQUEUEMEMORYSIZEPROC = size_t(*)(const NVNqueueBuilder*)

using PFNNVNQUEUEBUILDERSETQUEUEMEMORYPROC = void(*)(NVNqueueBuilder*, void*, size_t)

using PFNNVNQUEUEBUILDERSETCOMMANDFLUSHTHRESHOLDPROC = void(*)(NVNqueueBuilder*, size_t)

using PFNNVNQUEUEINITIALIZEPROC = NVNboolean(*)(NVNqueue*, const NVNqueueBuilder*)

using PFNNVNQUEUEFINALIZEPROC = void(*)(NVNqueue*)

using PFNNVNQUEUESETDEBUGLABELPROC = void(*)(NVNqueue*, const char*)

using PFNNVNQUEUESUBMITCOMMANDSPROC = void(*)(NVNqueue*, int, const NVNcommandHandle*)

using PFNNVNQUEUEFLUSHPROC = void(*)(NVNqueue*)

using PFNNVNQUEUEFINISHPROC = void(*)(NVNqueue*)

using PFNNVNQUEUEPRESENTTEXTUREPROC = void(*)(NVNqueue*, NVNwindow*, int)

using PFNNVNQUEUEACQUIRETEXTUREPROC = NVNqueueAcquireTextureResult(*)(NVNqueue*, NVNwindow*, int*)

using PFNNVNWINDOWBUILDERSETDEVICEPROC = void(*)(NVNwindowBuilder*, NVNdevice*)

using PFNNVNWINDOWBUILDERSETDEFAULTSPROC = void(*)(NVNwindowBuilder*)

using PFNNVNWINDOWBUILDERSETNATIVEWINDOWPROC = void(*)(NVNwindowBuilder*, NVNnativeWindow)

using PFNNVNWINDOWBUILDERSETTEXTURESPROC = void(*)(NVNwindowBuilder*, int, NVNtexture*const*)

using PFNNVNWINDOWBUILDERSETPRESENTINTERVALPROC = void(*)(NVNwindowBuilder*, int)

using PFNNVNWINDOWBUILDERGETNATIVEWINDOWPROC = NVNnativeWindow(*)(const NVNwindowBuilder*)

using PFNNVNWINDOWBUILDERGETPRESENTINTERVALPROC = int(*)(const NVNwindowBuilder*)

using PFNNVNWINDOWINITIALIZEPROC = NVNboolean(*)(NVNwindow*, const NVNwindowBuilder*)

using PFNNVNWINDOWFINALIZEPROC = void(*)(NVNwindow*)

using PFNNVNWINDOWSETDEBUGLABELPROC = void(*)(NVNwindow*, const char*)

using PFNNVNWINDOWACQUIRETEXTUREPROC = NVNwindowAcquireTextureResult(*)(NVNwindow*, NVNsync*, int*)

using PFNNVNWINDOWGETNATIVEWINDOWPROC = NVNnativeWindow(*)(const NVNwindow*)

using PFNNVNWINDOWGETPRESENTINTERVALPROC = int(*)(const NVNwindow*)

using PFNNVNWINDOWSETPRESENTINTERVALPROC = void(*)(NVNwindow*, int)

using PFNNVNWINDOWSETCROPPROC = void(*)(NVNwindow*, int, int, int, int)

using PFNNVNWINDOWGETCROPPROC = void(*)(const NVNwindow*, NVNrectangle*)

using PFNNVNPROGRAMINITIALIZEPROC = NVNboolean(*)(NVNprogram*, NVNdevice*)

using PFNNVNPROGRAMFINALIZEPROC = void(*)(NVNprogram*)

using PFNNVNPROGRAMSETDEBUGLABELPROC = void(*)(NVNprogram*, const char*)

using PFNNVNPROGRAMSETSHADERSPROC = NVNboolean(*)(NVNprogram*, int, const NVNshaderData*)

using PFNNVNMEMORYPOOLBUILDERSETDEVICEPROC = void(*)(NVNmemoryPoolBuilder*, NVNdevice*)

using PFNNVNMEMORYPOOLBUILDERSETDEFAULTSPROC = void(*)(NVNmemoryPoolBuilder*)

using PFNNVNMEMORYPOOLBUILDERSETSTORAGEPROC = void(*)(NVNmemoryPoolBuilder*, void*, size_t)

using PFNNVNMEMORYPOOLBUILDERSETFLAGSPROC = void(*)(NVNmemoryPoolBuilder*, int)

using PFNNVNMEMORYPOOLBUILDERGETMEMORYPROC = void(*)(const NVNmemoryPoolBuilder*)

using PFNNVNMEMORYPOOLBUILDERGETSIZEPROC = size_t(*)(const NVNmemoryPoolBuilder*)

using PFNNVNMEMORYPOOLBUILDERGETFLAGSPROC = NVNmemoryPoolFlags(*)(const NVNmemoryPoolBuilder*)

using PFNNVNMEMORYPOOLINITIALIZEPROC = NVNboolean(*)(NVNmemoryPool*, const NVNmemoryPoolBuilder*)

using PFNNVNMEMORYPOOLSETDEBUGLABELPROC = void(*)(NVNmemoryPool*, const char*)

using PFNNVNMEMORYPOOLFINALIZEPROC = void(*)(NVNmemoryPool*)

using PFNNVNMEMORYPOOLMAPPROC = void*(*)(const NVNmemoryPool*)

using PFNNVNMEMORYPOOLFLUSHMAPPEDRANGEPROC = void(*)(const NVNmemoryPool*, ptrdiff_t, size_t)

using PFNNVNMEMORYPOOLINVALIDATEMAPPEDRANGEPROC = void(*)(const NVNmemoryPool*, ptrdiff_t, size_t)

using PFNNVNMEMORYPOOLGETBUFFERADDRESSPROC = NVNbufferAddress(*)(const NVNmemoryPool*)

using PFNNVNMEMORYPOOLMAPVIRTUALPROC = NVNboolean(*)(NVNmemoryPool*, int, const NVNmappingRequest*)

using PFNNVNMEMORYPOOLGETSIZEPROC = size_t(*)(const NVNmemoryPool*)

using PFNNVNMEMORYPOOLGETFLAGSPROC = NVNmemoryPoolFlags(*)(const NVNmemoryPool*)

using PFNNVNTEXTUREPOOLINITIALIZEPROC = NVNboolean(*)(NVNtexturePool*, const NVNmemoryPool*, ptrdiff_t, int)

using PFNNVNTEXTUREPOOLSETDEBUGLABELPROC = void(*)(NVNtexturePool*, const char*)

using PFNNVNTEXTUREPOOLFINALIZEPROC = void(*)(NVNtexturePool*)

using PFNNVNTEXTUREPOOLREGISTERTEXTUREPROC = void(*)(const NVNtexturePool*, int, const NVNtexture*, const NVNtextureView*)

using PFNNVNTEXTUREPOOLREGISTERIMAGEPROC = void(*)(const NVNtexturePool*, int, const NVNtexture*, const NVNtextureView*)

using PFNNVNTEXTUREPOOLGETMEMORYPOOLPROC = const NVNmemoryPool*(*)(const NVNtexturePool*)

using PFNNVNTEXTUREPOOLGETMEMORYOFFSETPROC = ptrdiff_t(*)(const NVNtexturePool*)

using PFNNVNTEXTUREPOOLGETSIZEPROC = int(*)(const NVNtexturePool*)

using PFNNVNSAMPLERPOOLINITIALIZEPROC = NVNboolean(*)(NVNsamplerPool*, const NVNmemoryPool*, ptrdiff_t, int)

using PFNNVNSAMPLERPOOLSETDEBUGLABELPROC = void(*)(NVNsamplerPool*, const char*)

using PFNNVNSAMPLERPOOLFINALIZEPROC = void(*)(NVNsamplerPool*)

using PFNNVNSAMPLERPOOLREGISTERSAMPLERPROC = void(*)(const NVNsamplerPool*, int, const NVNsampler*)

using PFNNVNSAMPLERPOOLREGISTERSAMPLERBUILDERPROC = void(*)(const NVNsamplerPool*, int, const NVNsamplerBuilder*)

using PFNNVNSAMPLERPOOLGETMEMORYPOOLPROC = const NVNmemoryPool*(*)(const NVNsamplerPool*)

using PFNNVNSAMPLERPOOLGETMEMORYOFFSETPROC = ptrdiff_t(*)(const NVNsamplerPool*)

using PFNNVNSAMPLERPOOLGETSIZEPROC = int(*)(const NVNsamplerPool*)

using PFNNVNBUFFERBUILDERSETDEVICEPROC = void(*)(NVNbufferBuilder*, NVNdevice*)

using PFNNVNBUFFERBUILDERSETDEFAULTSPROC = void(*)(NVNbufferBuilder*)

using PFNNVNBUFFERBUILDERSETSTORAGEPROC = void(*)(NVNbufferBuilder*, NVNmemoryPool*, ptrdiff_t, size_t)

using PFNNVNBUFFERBUILDERGETMEMORYPOOLPROC = NVNmemoryPool(*)(const NVNbufferBuilder*)

using PFNNVNBUFFERBUILDERGETMEMORYOFFSETPROC = ptrdiff_t(*)(const NVNbufferBuilder*)

using PFNNVNBUFFERBUILDERGETSIZEPROC = size_t(*)(const NVNbufferBuilder*)

using PFNNVNBUFFERINITIALIZEPROC = NVNboolean(*)(NVNbuffer*, const NVNbufferBuilder*)

using PFNNVNBUFFERSETDEBUGLABELPROC = void(*)(NVNbuffer*, const char*)

using PFNNVNBUFFERFINALIZEPROC = void(*)(NVNbuffer*)

using PFNNVNBUFFERMAPPROC = void*(*)(const NVNbuffer*)

using PFNNVNBUFFERGETADDRESSPROC = NVNbufferAddress(*)(const NVNbuffer*)

using PFNNVNBUFFERFLUSHMAPPEDRANGEPROC = void(*)(const NVNbuffer*, ptrdiff_t, size_t)

using PFNNVNBUFFERINVALIDATEMAPPEDRANGEPROC = void(*)(const NVNbuffer*, ptrdiff_t, size_t)

using PFNNVNBUFFERGETMEMORYPOOLPROC = NVNmemoryPool*(*)(const NVNbuffer*)

using PFNNVNBUFFERGETMEMORYOFFSETPROC = ptrdiff_t(*)(const NVNbuffer*)

using PFNNVNBUFFERGETSIZEPROC = size_t(*)(const NVNbuffer*)

using PFNNVNBUFFERGETDEBUGIDPROC = uint64_t(*)(const NVNbuffer*)

using PFNNVNTEXTUREBUILDERSETDEVICEPROC = void(*)(NVNtextureBuilder*, NVNdevice*)

using PFNNVNTEXTUREBUILDERSETDEFAULTSPROC = void(*)(NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERSETFLAGSPROC = void(*)(NVNtextureBuilder*, int)

using PFNNVNTEXTUREBUILDERSETTARGETPROC = void(*)(NVNtextureBuilder*, NVNtextureTarget)

using PFNNVNTEXTUREBUILDERSETWIDTHPROC = void(*)(NVNtextureBuilder*, int)

using PFNNVNTEXTUREBUILDERSETHEIGHTPROC = void(*)(NVNtextureBuilder*, int)

using PFNNVNTEXTUREBUILDERSETDEPTHPROC = void(*)(NVNtextureBuilder*, int)

using PFNNVNTEXTUREBUILDERSETSIZE1DPROC = void(*)(NVNtextureBuilder*, int)

using PFNNVNTEXTUREBUILDERSETSIZE2DPROC = void(*)(NVNtextureBuilder*, int, int)

using PFNNVNTEXTUREBUILDERSETSIZE3DPROC = void(*)(NVNtextureBuilder*, int, int, int)

using PFNNVNTEXTUREBUILDERSETLEVELSPROC = void(*)(NVNtextureBuilder*, int)

using PFNNVNTEXTUREBUILDERSETFORMATPROC = void(*)(NVNtextureBuilder*, NVNformat)

using PFNNVNTEXTUREBUILDERSETSAMPLESPROC = void(*)(NVNtextureBuilder*, int)

using PFNNVNTEXTUREBUILDERSETSWIZZLEPROC = void(*)(NVNtextureBuilder*, NVNtextureSwizzle, NVNtextureSwizzle, NVNtextureSwizzle, NVNtextureSwizzle)

using PFNNVNTEXTUREBUILDERSETDEPTHSTENCILMODEPROC = void(*)(NVNtextureBuilder*, NVNtextureDepthStencilMode)

using PFNNVNTEXTUREBUILDERGETSTORAGESIZEPROC = size_t(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETSTORAGEALIGNMENTPROC = size_t(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERSETSTORAGEPROC = void(*)(NVNtextureBuilder*, NVNmemoryPool*, ptrdiff_t)

using PFNNVNTEXTUREBUILDERSETPACKAGEDTEXTUREDATAPROC = void(*)(NVNtextureBuilder*, const void*)

using PFNNVNTEXTUREBUILDERSETPACKAGEDTEXTURELAYOUTPROC = void(*)(NVNtextureBuilder*, const NVNpackagedTextureLayout*)

using PFNNVNTEXTUREBUILDERSETSTRIDEPROC = void(*)(NVNtextureBuilder*, ptrdiff_t)

using PFNNVNTEXTUREBUILDERSETGLTEXTURENAMEPROC = void(*)(NVNtextureBuilder*, uint32_t)

using PFNNVNTEXTUREBUILDERGETSTORAGECLASSPROC = NVNstorageClass(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETFLAGSPROC = NVNtextureFlags(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETTARGETPROC = NVNtextureTarget(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETWIDTHPROC = int(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETHEIGHTPROC = int(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETDEPTHPROC = int(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETLEVELSPROC = int(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETFORMATPROC = NVNformat(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETSAMPLESPROC = int(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETSWIZZLEPROC = void(*)(const NVNtextureBuilder*, NVNtextureSwizzle*, NVNtextureSwizzle*, NVNtextureSwizzle*, NVNtextureSwizzle*)

using PFNNVNTEXTUREBUILDERGETDEPTHSTENCILMODEPROC = NVNtextureDepthStencilMode(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETPACKAGEDTEXTUREDATAPROC = const void*(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETSTRIDEPROC = ptrdiff_t(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETSPARSETILELAYOUTPROC = void(*)(const NVNtextureBuilder*, NVNtextureSparseTileLayout*)

using PFNNVNTEXTUREBUILDERGETGLTEXTURENAMEPROC = uint32_t(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETZCULLSTORAGESIZEPROC = size_t(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETMEMORYPOOLPROC = NVNmemoryPool(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREBUILDERGETMEMORYOFFSETPROC = ptrdiff_t(*)(const NVNtextureBuilder*)

using PFNNVNTEXTUREVIEWSETDEFAULTSPROC = void(*)(NVNtextureView*)

using PFNNVNTEXTUREVIEWSETLEVELSPROC = void(*)(NVNtextureView*, int, int)

using PFNNVNTEXTUREVIEWSETLAYERSPROC = void(*)(NVNtextureView*, int, int)

using PFNNVNTEXTUREVIEWSETFORMATPROC = void(*)(NVNtextureView*, NVNformat)

using PFNNVNTEXTUREVIEWSETSWIZZLEPROC = void(*)(NVNtextureView*, NVNtextureSwizzle, NVNtextureSwizzle, NVNtextureSwizzle, NVNtextureSwizzle)

using PFNNVNTEXTUREVIEWSETDEPTHSTENCILMODEPROC = void(*)(NVNtextureView*, NVNtextureDepthStencilMode)

using PFNNVNTEXTUREVIEWSETTARGETPROC = void(*)(NVNtextureView*, NVNtextureTarget)

using PFNNVNTEXTUREVIEWGETLEVELSPROC = NVNboolean(*)(const NVNtextureView*, int*, int*)

using PFNNVNTEXTUREVIEWGETLAYERSPROC = NVNboolean(*)(const NVNtextureView*, int*, int*)

using PFNNVNTEXTUREVIEWGETFORMATPROC = NVNboolean(*)(const NVNtextureView*, NVNformat*)

using PFNNVNTEXTUREVIEWGETSWIZZLEPROC = NVNboolean(*)(const NVNtextureView*, NVNtextureSwizzle*, NVNtextureSwizzle*, NVNtextureSwizzle*, NVNtextureSwizzle*)

using PFNNVNTEXTUREVIEWGETDEPTHSTENCILMODEPROC = NVNboolean(*)(const NVNtextureView*, NVNtextureDepthStencilMode*)

using PFNNVNTEXTUREVIEWGETTARGETPROC = NVNboolean(*)(const NVNtextureView*, NVNtextureTarget*)

using PFNNVNTEXTUREVIEWCOMPAREPROC = NVNboolean(*)(const NVNtextureView*, const NVNtextureView*)

using PFNNVNTEXTUREINITIALIZEPROC = NVNboolean(*)(NVNtexture*, const NVNtextureBuilder*)

using PFNNVNTEXTUREGETZCULLSTORAGESIZEPROC = size_t(*)(const NVNtexture*)

using PFNNVNTEXTUREFINALIZEPROC = void(*)(NVNtexture*)

using PFNNVNTEXTURESETDEBUGLABELPROC = void(*)(NVNtexture*, const char*)

using PFNNVNTEXTUREGETSTORAGECLASSPROC = NVNstorageClass(*)(const NVNtexture*)

using PFNNVNTEXTUREGETVIEWOFFSETPROC = ptrdiff_t(*)(const NVNtexture*, const NVNtextureView*)

using PFNNVNTEXTUREGETFLAGSPROC = NVNtextureFlags(*)(const NVNtexture*)

using PFNNVNTEXTUREGETTARGETPROC = NVNtextureTarget(*)(const NVNtexture*)

using PFNNVNTEXTUREGETWIDTHPROC = int(*)(const NVNtexture*)

using PFNNVNTEXTUREGETHEIGHTPROC = int(*)(const NVNtexture*)

using PFNNVNTEXTUREGETDEPTHPROC = int(*)(const NVNtexture*)

using PFNNVNTEXTUREGETLEVELSPROC = int(*)(const NVNtexture*)

using PFNNVNTEXTUREGETFORMATPROC = NVNformat(*)(const NVNtexture*)

using PFNNVNTEXTUREGETSAMPLESPROC = int(*)(const NVNtexture*)

using PFNNVNTEXTUREGETSWIZZLEPROC = void(*)(const NVNtexture*, NVNtextureSwizzle*, NVNtextureSwizzle*, NVNtextureSwizzle*, NVNtextureSwizzle*)

using PFNNVNTEXTUREGETDEPTHSTENCILMODEPROC = NVNtextureDepthStencilMode(*)(const NVNtexture*)

using PFNNVNTEXTUREGETSTRIDEPROC = ptrdiff_t(*)(const NVNtexture*)

using PFNNVNTEXTUREGETTEXTUREADDRESSPROC = NVNtextureAddress(*)(const NVNtexture*)

using PFNNVNTEXTUREGETSPARSETILELAYOUTPROC = void(*)(const NVNtexture*, NVNtextureSparseTileLayout*)

using PFNNVNTEXTUREWRITETEXELSPROC = void(*)(const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*, const void*)

using PFNNVNTEXTUREWRITETEXELSSTRIDEDPROC = void(*)(const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*, const void*, ptrdiff_t, ptrdiff_t)

using PFNNVNTEXTUREREADTEXELSPROC = void(*)(const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*, void*)

using PFNNVNTEXTUREREADTEXELSSTRIDEDPROC = void(*)(const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*, void*, ptrdiff_t, ptrdiff_t)

using PFNNVNTEXTUREFLUSHTEXELSPROC = void(*)(const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*)

using PFNNVNTEXTUREINVALIDATETEXELSPROC = void(*)(const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*)

using PFNNVNTEXTUREGETMEMORYPOOLPROC = NVNmemoryPool(*)(const NVNtexture*)

using PFNNVNTEXTUREGETMEMORYOFFSETPROC = ptrdiff_t(*)(const NVNtexture*)

using PFNNVNTEXTUREGETSTORAGESIZEPROC = int(*)(const NVNtexture*)

using PFNNVNTEXTURECOMPAREPROC = NVNboolean(*)(const NVNtexture*, const NVNtexture*)

using PFNNVNTEXTUREGETDEBUGIDPROC = uint64_t(*)(const NVNtexture*)

using PFNNVNSAMPLERBUILDERSETDEVICEPROC = void(*)(NVNsamplerBuilder*, NVNdevice*)

using PFNNVNSAMPLERBUILDERSETDEFAULTSPROC = void(*)(NVNsamplerBuilder*)

using PFNNVNSAMPLERBUILDERSETMINMAGFILTERPROC = void(*)(NVNsamplerBuilder*, NVNminFilter, NVNmagFilter)

using PFNNVNSAMPLERBUILDERSETWRAPMODEPROC = void(*)(NVNsamplerBuilder*, NVNwrapMode, NVNwrapMode, NVNwrapMode)

using PFNNVNSAMPLERBUILDERSETLODCLAMPPROC = void(*)(NVNsamplerBuilder*, float, float)

using PFNNVNSAMPLERBUILDERSETLODBIASPROC = void(*)(NVNsamplerBuilder*, float)

using PFNNVNSAMPLERBUILDERSETCOMPAREPROC = void(*)(NVNsamplerBuilder*, NVNcompareMode, NVNcompareFunc)

using PFNNVNSAMPLERBUILDERSETBORDERCOLORPROC = void(*)(NVNsamplerBuilder*, const float*)

using PFNNVNSAMPLERBUILDERSETBORDERCOLORIPROC = void(*)(NVNsamplerBuilder*, const int*)

using PFNNVNSAMPLERBUILDERSETBORDERCOLORUIPROC = void(*)(NVNsamplerBuilder*, const uint32_t*)

using PFNNVNSAMPLERBUILDERSETMAXANISOTROPYPROC = void(*)(NVNsamplerBuilder*, float)

using PFNNVNSAMPLERBUILDERSETREDUCTIONFILTERPROC = void(*)(NVNsamplerBuilder*, NVNsamplerReduction)

using PFNNVNSAMPLERBUILDERSETLODSNAPPROC = void(*)(NVNsamplerBuilder*, float)

using PFNNVNSAMPLERBUILDERGETMINMAGFILTERPROC = void(*)(const NVNsamplerBuilder*, NVNminFilter*, NVNmagFilter*)

using PFNNVNSAMPLERBUILDERGETWRAPMODEPROC = void(*)(const NVNsamplerBuilder*, NVNwrapMode*, NVNwrapMode*, NVNwrapMode*)

using PFNNVNSAMPLERBUILDERGETLODCLAMPPROC = void(*)(const NVNsamplerBuilder*, float*, float*)

using PFNNVNSAMPLERBUILDERGETLODBIASPROC = float(*)(const NVNsamplerBuilder*)

using PFNNVNSAMPLERBUILDERGETCOMPAREPROC = void(*)(const NVNsamplerBuilder*, NVNcompareMode*, NVNcompareFunc*)

using PFNNVNSAMPLERBUILDERGETBORDERCOLORPROC = void(*)(const NVNsamplerBuilder*, float*)

using PFNNVNSAMPLERBUILDERGETBORDERCOLORIPROC = void(*)(const NVNsamplerBuilder*, int*)

using PFNNVNSAMPLERBUILDERGETBORDERCOLORUIPROC = void(*)(const NVNsamplerBuilder*, uint32_t*)

using PFNNVNSAMPLERBUILDERGETMAXANISOTROPYPROC = float(*)(const NVNsamplerBuilder*)

using PFNNVNSAMPLERBUILDERGETREDUCTIONFILTERPROC = NVNsamplerReduction(*)(const NVNsamplerBuilder*)

using PFNNVNSAMPLERBUILDERGETLODSNAPPROC = float(*)(const NVNsamplerBuilder*)

using PFNNVNSAMPLERINITIALIZEPROC = NVNboolean(*)(NVNsampler*, const NVNsamplerBuilder*)

using PFNNVNSAMPLERFINALIZEPROC = void(*)(NVNsampler*)

using PFNNVNSAMPLERSETDEBUGLABELPROC = void(*)(NVNsampler*, const char*)

using PFNNVNSAMPLERGETMINMAGFILTERPROC = void(*)(const NVNsampler*, NVNminFilter*, NVNmagFilter*)

using PFNNVNSAMPLERGETWRAPMODEPROC = void(*)(const NVNsampler*, NVNwrapMode*, NVNwrapMode*, NVNwrapMode*)

using PFNNVNSAMPLERGETLODCLAMPPROC = void(*)(const NVNsampler*, float*, float*)

using PFNNVNSAMPLERGETLODBIASPROC = float(*)(const NVNsampler*)

using PFNNVNSAMPLERGETCOMPAREPROC = void(*)(const NVNsampler*, NVNcompareMode*, NVNcompareFunc*)

using PFNNVNSAMPLERGETBORDERCOLORPROC = void(*)(const NVNsampler*, float*)

using PFNNVNSAMPLERGETBORDERCOLORIPROC = void(*)(const NVNsampler*, int*)

using PFNNVNSAMPLERGETBORDERCOLORUIPROC = void(*)(const NVNsampler*, uint32_t*)

using PFNNVNSAMPLERGETMAXANISOTROPYPROC = float(*)(const NVNsampler*)

using PFNNVNSAMPLERGETREDUCTIONFILTERPROC = NVNsamplerReduction(*)(const NVNsampler*)

using PFNNVNSAMPLERCOMPAREPROC = NVNboolean(*)(const NVNsampler*, const NVNsampler*)

using PFNNVNSAMPLERGETDEBUGIDPROC = uint64_t(*)(const NVNsampler*)

using PFNNVNBLENDSTATESETDEFAULTSPROC = void(*)(NVNblendState*)

using PFNNVNBLENDSTATESETBLENDTARGETPROC = void(*)(NVNblendState*, int)

using PFNNVNBLENDSTATESETBLENDFUNCPROC = void(*)(NVNblendState*, NVNblendFunc, NVNblendFunc, NVNblendFunc, NVNblendFunc)

using PFNNVNBLENDSTATESETBLENDEQUATIONPROC = void(*)(NVNblendState*, NVNblendEquation, NVNblendEquation)

using PFNNVNBLENDSTATESETADVANCEDMODEPROC = void(*)(NVNblendState*, NVNblendAdvancedMode)

using PFNNVNBLENDSTATESETADVANCEDOVERLAPPROC = void(*)(NVNblendState*, NVNblendAdvancedOverlap)

using PFNNVNBLENDSTATESETADVANCEDPREMULTIPLIEDSRCPROC = void(*)(NVNblendState*, NVNboolean)

using PFNNVNBLENDSTATESETADVANCEDNORMALIZEDDSTPROC = void(*)(NVNblendState*, NVNboolean)

using PFNNVNBLENDSTATEGETBLENDTARGETPROC = int(*)(const NVNblendState*)

using PFNNVNBLENDSTATEGETBLENDFUNCPROC = void(*)(const NVNblendState*, NVNblendFunc*, NVNblendFunc*, NVNblendFunc*, NVNblendFunc*)

using PFNNVNBLENDSTATEGETBLENDEQUATIONPROC = void(*)(const NVNblendState*, NVNblendEquation*, NVNblendEquation*)

using PFNNVNBLENDSTATEGETADVANCEDMODEPROC = NVNblendAdvancedMode(*)(const NVNblendState*)

using PFNNVNBLENDSTATEGETADVANCEDOVERLAPPROC = NVNblendAdvancedOverlap(*)(const NVNblendState*)

using PFNNVNBLENDSTATEGETADVANCEDPREMULTIPLIEDSRCPROC = NVNboolean(*)(const NVNblendState*)

using PFNNVNBLENDSTATEGETADVANCEDNORMALIZEDDSTPROC = NVNboolean(*)(const NVNblendState*)

using PFNNVNCOLORSTATESETDEFAULTSPROC = void(*)(NVNcolorState*)

using PFNNVNCOLORSTATESETBLENDENABLEPROC = void(*)(NVNcolorState*, int, NVNboolean)

using PFNNVNCOLORSTATESETLOGICOPPROC = void(*)(NVNcolorState*, NVNlogicOp)

using PFNNVNCOLORSTATESETALPHATESTPROC = void(*)(NVNcolorState*, NVNalphaFunc)

using PFNNVNCOLORSTATEGETBLENDENABLEPROC = NVNboolean(*)(const NVNcolorState*, int)

using PFNNVNCOLORSTATEGETLOGICOPPROC = NVNlogicOp(*)(const NVNcolorState*)

using PFNNVNCOLORSTATEGETALPHATESTPROC = NVNalphaFunc(*)(const NVNcolorState*)

using PFNNVNCHANNELMASKSTATESETDEFAULTSPROC = void(*)(NVNchannelMaskState*)

using PFNNVNCHANNELMASKSTATESETCHANNELMASKPROC = void(*)(NVNchannelMaskState*, int, NVNboolean, NVNboolean, NVNboolean, NVNboolean)

using PFNNVNCHANNELMASKSTATEGETCHANNELMASKPROC = void(*)(const NVNchannelMaskState*, int, NVNboolean*, NVNboolean*, NVNboolean*, NVNboolean*)

using PFNNVNMULTISAMPLESTATESETDEFAULTSPROC = void(*)(NVNmultisampleState*)

using PFNNVNMULTISAMPLESTATESETMULTISAMPLEENABLEPROC = void(*)(NVNmultisampleState*, NVNboolean)

using PFNNVNMULTISAMPLESTATESETSAMPLESPROC = void(*)(NVNmultisampleState*, int)

using PFNNVNMULTISAMPLESTATESETALPHATOCOVERAGEENABLEPROC = void(*)(NVNmultisampleState*, NVNboolean)

using PFNNVNMULTISAMPLESTATESETALPHATOCOVERAGEDITHERPROC = void(*)(NVNmultisampleState*, NVNboolean)

using PFNNVNMULTISAMPLESTATEGETMULTISAMPLEENABLEPROC = NVNboolean(*)(const NVNmultisampleState*)

using PFNNVNMULTISAMPLESTATEGETSAMPLESPROC = int(*)(const NVNmultisampleState*)

using PFNNVNMULTISAMPLESTATEGETALPHATOCOVERAGEENABLEPROC = NVNboolean(*)(const NVNmultisampleState*)

using PFNNVNMULTISAMPLESTATEGETALPHATOCOVERAGEDITHERPROC = NVNboolean(*)(const NVNmultisampleState*)

using PFNNVNMULTISAMPLESTATESETRASTERSAMPLESPROC = void(*)(NVNmultisampleState*, int)

using PFNNVNMULTISAMPLESTATEGETRASTERSAMPLESPROC = int(*)(NVNmultisampleState*)

using PFNNVNMULTISAMPLESTATESETCOVERAGEMODULATIONMODEPROC = void(*)(NVNmultisampleState*, NVNcoverageModulationMode)

using PFNNVNMULTISAMPLESTATEGETCOVERAGEMODULATIONMODEPROC = NVNcoverageModulationMode(*)(const NVNmultisampleState*)

using PFNNVNMULTISAMPLESTATESETCOVERAGETOCOLORENABLEPROC = void(*)(NVNmultisampleState*, NVNboolean)

using PFNNVNMULTISAMPLESTATEGETCOVERAGETOCOLORENABLEPROC = NVNboolean(*)(const NVNmultisampleState*)

using PFNNVNMULTISAMPLESTATESETCOVERAGETOCOLOROUTPUTPROC = void(*)(NVNmultisampleState*, int)

using PFNNVNMULTISAMPLESTATEGETCOVERAGETOCOLOROUTPUTPROC = int(*)(const NVNmultisampleState*)

using PFNNVNMULTISAMPLESTATESETSAMPLELOCATIONSENABLEPROC = void(*)(NVNmultisampleState*, NVNboolean)

using PFNNVNMULTISAMPLESTATEGETSAMPLELOCATIONSENABLEPROC = NVNboolean(*)(const NVNmultisampleState*)

using PFNNVNMULTISAMPLESTATEGETSAMPLELOCATIONSGRIDPROC = void(*)(NVNmultisampleState*, int*, int*)

using PFNNVNMULTISAMPLESTATESETSAMPLELOCATIONSGRIDENABLEPROC = void(*)(NVNmultisampleState*, NVNboolean)

using PFNNVNMULTISAMPLESTATEGETSAMPLELOCATIONSGRIDENABLEPROC = NVNboolean(*)(const NVNmultisampleState*)

using PFNNVNMULTISAMPLESTATESETSAMPLELOCATIONSPROC = void(*)(NVNmultisampleState*, int, int, const float*)

using PFNNVNPOLYGONSTATESETDEFAULTSPROC = void(*)(NVNpolygonState*)

using PFNNVNPOLYGONSTATESETCULLFACEPROC = void(*)(NVNpolygonState*, NVNface)

using PFNNVNPOLYGONSTATESETFRONTFACEPROC = void(*)(NVNpolygonState*, NVNfrontFace)

using PFNNVNPOLYGONSTATESETPOLYGONMODEPROC = void(*)(NVNpolygonState*, NVNpolygonMode)

using PFNNVNPOLYGONSTATESETPOLYGONOFFSETENABLESPROC = void(*)(NVNpolygonState*, int)

using PFNNVNPOLYGONSTATEGETCULLFACEPROC = NVNface(*)(const NVNpolygonState*)

using PFNNVNPOLYGONSTATEGETFRONTFACEPROC = NVNfrontFace(*)(const NVNpolygonState*)

using PFNNVNPOLYGONSTATEGETPOLYGONMODEPROC = NVNpolygonMode(*)(const NVNpolygonState*)

using PFNNVNPOLYGONSTATEGETPOLYGONOFFSETENABLESPROC = NVNpolygonOffsetEnable(*)(const NVNpolygonState*)

using PFNNVNDEPTHSTENCILSTATESETDEFAULTSPROC = void(*)(NVNdepthStencilState*)

using PFNNVNDEPTHSTENCILSTATESETDEPTHTESTENABLEPROC = void(*)(NVNdepthStencilState*, NVNboolean)

using PFNNVNDEPTHSTENCILSTATESETDEPTHWRITEENABLEPROC = void(*)(NVNdepthStencilState*, NVNboolean)

using PFNNVNDEPTHSTENCILSTATESETDEPTHFUNCPROC = void(*)(NVNdepthStencilState*, NVNdepthFunc)

using PFNNVNDEPTHSTENCILSTATESETSTENCILTESTENABLEPROC = void(*)(NVNdepthStencilState*, NVNboolean)

using PFNNVNDEPTHSTENCILSTATESETSTENCILFUNCPROC = void(*)(NVNdepthStencilState*, NVNface, NVNstencilFunc)

using PFNNVNDEPTHSTENCILSTATESETSTENCILOPPROC = void(*)(NVNdepthStencilState*, NVNface, NVNstencilOp, NVNstencilOp, NVNstencilOp)

using PFNNVNDEPTHSTENCILSTATEGETDEPTHTESTENABLEPROC = NVNboolean(*)(const NVNdepthStencilState*)

using PFNNVNDEPTHSTENCILSTATEGETDEPTHWRITEENABLEPROC = NVNboolean(*)(const NVNdepthStencilState*)

using PFNNVNDEPTHSTENCILSTATEGETDEPTHFUNCPROC = NVNdepthFunc(*)(const NVNdepthStencilState*)

using PFNNVNDEPTHSTENCILSTATEGETSTENCILTESTENABLEPROC = NVNboolean(*)(const NVNdepthStencilState*)

using PFNNVNDEPTHSTENCILSTATEGETSTENCILFUNCPROC = NVNstencilFunc(*)(const NVNdepthStencilState*, NVNface)

using PFNNVNDEPTHSTENCILSTATEGETSTENCILOPPROC = void(*)(const NVNdepthStencilState*, NVNface, NVNstencilOp*, NVNstencilOp*, NVNstencilOp*)

using PFNNVNVERTEXATTRIBSTATESETDEFAULTSPROC = void(*)(NVNvertexAttribState*)

using PFNNVNVERTEXATTRIBSTATESETFORMATPROC = void(*)(NVNvertexAttribState*, NVNformat, ptrdiff_t)

using PFNNVNVERTEXATTRIBSTATESETSTREAMINDEXPROC = void(*)(NVNvertexAttribState*, int)

using PFNNVNVERTEXATTRIBSTATEGETFORMATPROC = void(*)(const NVNvertexAttribState*, NVNformat*, ptrdiff_t*)

using PFNNVNVERTEXATTRIBSTATEGETSTREAMINDEXPROC = int(*)(const NVNvertexAttribState*)

using PFNNVNVERTEXSTREAMSTATESETDEFAULTSPROC = void(*)(NVNvertexStreamState*)

using PFNNVNVERTEXSTREAMSTATESETSTRIDEPROC = void(*)(NVNvertexStreamState*, ptrdiff_t)

using PFNNVNVERTEXSTREAMSTATESETDIVISORPROC = void(*)(NVNvertexStreamState*, int)

using PFNNVNVERTEXSTREAMSTATEGETSTRIDEPROC = ptrdiff_t(*)(const NVNvertexStreamState*)

using PFNNVNVERTEXSTREAMSTATEGETDIVISORPROC = int(*)(const NVNvertexStreamState*)

using PFNNVNCOMMANDBUFFERINITIALIZEPROC = NVNboolean(*)(NVNcommandBuffer*, NVNdevice*)

using PFNNVNCOMMANDBUFFERFINALIZEPROC = void(*)(NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERSETDEBUGLABELPROC = void(*)(NVNcommandBuffer*, const char*)

using PFNNVNCOMMANDBUFFERSETMEMORYCALLBACKPROC = void(*)(NVNcommandBuffer*, PFNNVNCOMMANDBUFFERMEMORYCALLBACKPROC)

using PFNNVNCOMMANDBUFFERSETMEMORYCALLBACKDATAPROC = void(*)(NVNcommandBuffer*, void*)

using PFNNVNCOMMANDBUFFERADDCOMMANDMEMORYPROC = void(*)(NVNcommandBuffer*, const NVNmemoryPool*, ptrdiff_t, size_t)

using PFNNVNCOMMANDBUFFERADDCONTROLMEMORYPROC = void(*)(NVNcommandBuffer*, void*, size_t)

using PFNNVNCOMMANDBUFFERGETCOMMANDMEMORYSIZEPROC = size_t(*)(const NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERGETCOMMANDMEMORYUSEDPROC = size_t(*)(const NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERGETCOMMANDMEMORYFREEPROC = size_t(*)(const NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERGETCONTROLMEMORYSIZEPROC = size_t(*)(const NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERGETCONTROLMEMORYUSEDPROC = size_t(*)(const NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERGETCONTROLMEMORYFREEPROC = size_t(*)(const NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERBEGINRECORDINGPROC = void(*)(NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERENDRECORDINGPROC = NVNcommandHandle(*)(NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERCALLCOMMANDSPROC = void(*)(NVNcommandBuffer*, int, const NVNcommandHandle*)

using PFNNVNCOMMANDBUFFERCOPYCOMMANDSPROC = void(*)(NVNcommandBuffer*, int, const NVNcommandHandle*)

using PFNNVNCOMMANDBUFFERBINDBLENDSTATEPROC = void(*)(NVNcommandBuffer*, const NVNblendState*)

using PFNNVNCOMMANDBUFFERBINDCHANNELMASKSTATEPROC = void(*)(NVNcommandBuffer*, const NVNchannelMaskState*)

using PFNNVNCOMMANDBUFFERBINDCOLORSTATEPROC = void(*)(NVNcommandBuffer*, const NVNcolorState*)

using PFNNVNCOMMANDBUFFERBINDMULTISAMPLESTATEPROC = void(*)(NVNcommandBuffer*, const NVNmultisampleState*)

using PFNNVNCOMMANDBUFFERBINDPOLYGONSTATEPROC = void(*)(NVNcommandBuffer*, const NVNpolygonState*)

using PFNNVNCOMMANDBUFFERBINDDEPTHSTENCILSTATEPROC = void(*)(NVNcommandBuffer*, const NVNdepthStencilState*)

using PFNNVNCOMMANDBUFFERBINDVERTEXATTRIBSTATEPROC = void(*)(NVNcommandBuffer*, int, const NVNvertexAttribState*)

using PFNNVNCOMMANDBUFFERBINDVERTEXSTREAMSTATEPROC = void(*)(NVNcommandBuffer*, int, const NVNvertexStreamState*)

using PFNNVNCOMMANDBUFFERBINDPROGRAMPROC = void(*)(NVNcommandBuffer*, const NVNprogram*, int)

using PFNNVNCOMMANDBUFFERBINDVERTEXBUFFERPROC = void(*)(NVNcommandBuffer*, int, NVNbufferAddress, size_t)

using PFNNVNCOMMANDBUFFERBINDVERTEXBUFFERSPROC = void(*)(NVNcommandBuffer*, int, int, const NVNbufferRange*)

using PFNNVNCOMMANDBUFFERBINDUNIFORMBUFFERPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, NVNbufferAddress, size_t)

using PFNNVNCOMMANDBUFFERBINDUNIFORMBUFFERSPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, int, const NVNbufferRange*)

using PFNNVNCOMMANDBUFFERBINDTRANSFORMFEEDBACKBUFFERPROC = void(*)(NVNcommandBuffer*, int, NVNbufferAddress, size_t)

using PFNNVNCOMMANDBUFFERBINDTRANSFORMFEEDBACKBUFFERSPROC = void(*)(NVNcommandBuffer*, int, int, const NVNbufferRange*)

using PFNNVNCOMMANDBUFFERBINDSTORAGEBUFFERPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, NVNbufferAddress, size_t)

using PFNNVNCOMMANDBUFFERBINDSTORAGEBUFFERSPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, int, const NVNbufferRange*)

using PFNNVNCOMMANDBUFFERBINDTEXTUREPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, NVNtextureHandle)

using PFNNVNCOMMANDBUFFERBINDTEXTURESPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, int, const NVNtextureHandle*)

using PFNNVNCOMMANDBUFFERBINDIMAGEPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, NVNimageHandle)

using PFNNVNCOMMANDBUFFERBINDIMAGESPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, int, const NVNimageHandle*)

using PFNNVNCOMMANDBUFFERSETPATCHSIZEPROC = void(*)(NVNcommandBuffer*, int)

using PFNNVNCOMMANDBUFFERSETINNERTESSELLATIONLEVELSPROC = void(*)(NVNcommandBuffer*, const float*)

using PFNNVNCOMMANDBUFFERSETOUTERTESSELLATIONLEVELSPROC = void(*)(NVNcommandBuffer*, const float*)

using PFNNVNCOMMANDBUFFERSETPRIMITIVERESTARTPROC = void(*)(NVNcommandBuffer*, NVNboolean, int)

using PFNNVNCOMMANDBUFFERBEGINTRANSFORMFEEDBACKPROC = void(*)(NVNcommandBuffer*, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERENDTRANSFORMFEEDBACKPROC = void(*)(NVNcommandBuffer*, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERPAUSETRANSFORMFEEDBACKPROC = void(*)(NVNcommandBuffer*, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERRESUMETRANSFORMFEEDBACKPROC = void(*)(NVNcommandBuffer*, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERDRAWTRANSFORMFEEDBACKPROC = void(*)(NVNcommandBuffer*, NVNdrawPrimitive, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERDRAWARRAYSPROC = void(*)(NVNcommandBuffer*, NVNdrawPrimitive, int, int)

using PFNNVNCOMMANDBUFFERDRAWELEMENTSPROC = void(*)(NVNcommandBuffer*, NVNdrawPrimitive, NVNindexType, int, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERDRAWELEMENTSBASEVERTEXPROC = void(*)(NVNcommandBuffer*, NVNdrawPrimitive, NVNindexType, int, NVNbufferAddress, int)

using PFNNVNCOMMANDBUFFERDRAWARRAYSINSTANCEDPROC = void(*)(NVNcommandBuffer*, NVNdrawPrimitive, int, int, int, int)

using PFNNVNCOMMANDBUFFERDRAWELEMENTSINSTANCEDPROC = void(*)(NVNcommandBuffer*, NVNdrawPrimitive, NVNindexType, int, NVNbufferAddress, int, int, int)

using PFNNVNCOMMANDBUFFERDRAWARRAYSINDIRECTPROC = void(*)(NVNcommandBuffer*, NVNdrawPrimitive, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERDRAWELEMENTSINDIRECTPROC = void(*)(NVNcommandBuffer*, NVNdrawPrimitive, NVNindexType, NVNbufferAddress, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERMULTIDRAWARRAYSINDIRECTCOUNTPROC = void(*)(NVNcommandBuffer*, NVNdrawPrimitive, NVNbufferAddress, NVNbufferAddress, int, ptrdiff_t)

using PFNNVNCOMMANDBUFFERMULTIDRAWELEMENTSINDIRECTCOUNTPROC = void(*)(NVNcommandBuffer*, NVNdrawPrimitive, NVNindexType, NVNbufferAddress, NVNbufferAddress, NVNbufferAddress, int, ptrdiff_t)

using PFNNVNCOMMANDBUFFERCLEARCOLORPROC = void(*)(NVNcommandBuffer*, int, const float*, int)

using PFNNVNCOMMANDBUFFERCLEARCOLORIPROC = void(*)(NVNcommandBuffer*, int, const int*, int)

using PFNNVNCOMMANDBUFFERCLEARCOLORUIPROC = void(*)(NVNcommandBuffer*, int, const uint32_t*, int)

using PFNNVNCOMMANDBUFFERCLEARDEPTHSTENCILPROC = void(*)(NVNcommandBuffer*, float, NVNboolean, int, int)

using PFNNVNCOMMANDBUFFERDISPATCHCOMPUTEPROC = void(*)(NVNcommandBuffer*, int, int, int)

using PFNNVNCOMMANDBUFFERDISPATCHCOMPUTEINDIRECTPROC = void(*)(NVNcommandBuffer*, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERSETVIEWPORTPROC = void(*)(NVNcommandBuffer*, int, int, int, int)

using PFNNVNCOMMANDBUFFERSETVIEWPORTSPROC = void(*)(NVNcommandBuffer*, int, int, const float*)

using PFNNVNCOMMANDBUFFERSETVIEWPORTSWIZZLESPROC = void(*)(NVNcommandBuffer*, int, int, const NVNviewportSwizzle*)

using PFNNVNCOMMANDBUFFERSETSCISSORPROC = void(*)(NVNcommandBuffer*, int, int, int, int)

using PFNNVNCOMMANDBUFFERSETSCISSORSPROC = void(*)(NVNcommandBuffer*, int, int, const int*)

using PFNNVNCOMMANDBUFFERSETDEPTHRANGEPROC = void(*)(NVNcommandBuffer*, float, float)

using PFNNVNCOMMANDBUFFERSETDEPTHBOUNDSPROC = void(*)(NVNcommandBuffer*, NVNboolean, float, float)

using PFNNVNCOMMANDBUFFERSETDEPTHRANGESPROC = void(*)(NVNcommandBuffer*, int, int, const float*)

using PFNNVNCOMMANDBUFFERSETTILEDCACHEACTIONPROC = void(*)(NVNcommandBuffer*, NVNtiledCacheAction)

using PFNNVNCOMMANDBUFFERSETTILEDCACHETILESIZEPROC = void(*)(NVNcommandBuffer*, int, int)

using PFNNVNCOMMANDBUFFERBINDSEPARATETEXTUREPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, NVNseparateTextureHandle)

using PFNNVNCOMMANDBUFFERBINDSEPARATESAMPLERPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, NVNseparateSamplerHandle)

using PFNNVNCOMMANDBUFFERBINDSEPARATETEXTURESPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, int, const NVNseparateTextureHandle*)

using PFNNVNCOMMANDBUFFERBINDSEPARATESAMPLERSPROC = void(*)(NVNcommandBuffer*, NVNshaderStage, int, int, const NVNseparateSamplerHandle*)

using PFNNVNCOMMANDBUFFERSETSTENCILVALUEMASKPROC = void(*)(NVNcommandBuffer*, NVNface, int)

using PFNNVNCOMMANDBUFFERSETSTENCILMASKPROC = void(*)(NVNcommandBuffer*, NVNface, int)

using PFNNVNCOMMANDBUFFERSETSTENCILREFPROC = void(*)(NVNcommandBuffer*, NVNface, int)

using PFNNVNCOMMANDBUFFERSETBLENDCOLORPROC = void(*)(NVNcommandBuffer*, const float*)

using PFNNVNCOMMANDBUFFERSETPOINTSIZEPROC = void(*)(NVNcommandBuffer*, float)

using PFNNVNCOMMANDBUFFERSETLINEWIDTHPROC = void(*)(NVNcommandBuffer*, float)

using PFNNVNCOMMANDBUFFERSETPOLYGONOFFSETCLAMPPROC = void(*)(NVNcommandBuffer*, float, float, float)

using PFNNVNCOMMANDBUFFERSETALPHAREFPROC = void(*)(NVNcommandBuffer*, float)

using PFNNVNCOMMANDBUFFERSETSAMPLEMASKPROC = void(*)(NVNcommandBuffer*, int)

using PFNNVNCOMMANDBUFFERSETRASTERIZERDISCARDPROC = void(*)(NVNcommandBuffer*, NVNboolean)

using PFNNVNCOMMANDBUFFERSETDEPTHCLAMPPROC = void(*)(NVNcommandBuffer*, NVNboolean)

using PFNNVNCOMMANDBUFFERSETCONSERVATIVERASTERENABLEPROC = void(*)(NVNcommandBuffer*, NVNboolean)

using PFNNVNCOMMANDBUFFERSETCONSERVATIVERASTERDILATEPROC = void(*)(NVNcommandBuffer*, float)

using PFNNVNCOMMANDBUFFERSETSUBPIXELPRECISIONBIASPROC = void(*)(NVNcommandBuffer*, int, int)

using PFNNVNCOMMANDBUFFERCOPYBUFFERTOTEXTUREPROC = void(*)(NVNcommandBuffer*, NVNbufferAddress, const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*, int)

using PFNNVNCOMMANDBUFFERCOPYTEXTURETOBUFFERPROC = void(*)(NVNcommandBuffer*, const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*, NVNbufferAddress, int)

using PFNNVNCOMMANDBUFFERCOPYTEXTURETOTEXTUREPROC = void(*)(NVNcommandBuffer*, const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*, const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*, int)

using PFNNVNCOMMANDBUFFERCOPYBUFFERTOBUFFERPROC = void(*)(NVNcommandBuffer*, NVNbufferAddress, NVNbufferAddress, size_t, int)

using PFNNVNCOMMANDBUFFERCLEARBUFFERPROC = void(*)(NVNcommandBuffer*, NVNbufferAddress, size_t, uint32_t)

using PFNNVNCOMMANDBUFFERCLEARTEXTUREPROC = void(*)(NVNcommandBuffer*, const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*, const float*, int)

using PFNNVNCOMMANDBUFFERCLEARTEXTUREIPROC = void(*)(NVNcommandBuffer*, const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*, const int*, int)

using PFNNVNCOMMANDBUFFERCLEARTEXTUREUIPROC = void(*)(NVNcommandBuffer*, const NVNtexture*, const NVNtextureView*, const NVNcopyRegion*, const uint32_t*, int)

using PFNNVNCOMMANDBUFFERUPDATEUNIFORMBUFFERPROC = void(*)(NVNcommandBuffer*, NVNbufferAddress, size_t, ptrdiff_t, size_t, const void*)

using PFNNVNCOMMANDBUFFERREPORTCOUNTERPROC = void(*)(NVNcommandBuffer*, NVNcounterType, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERRESETCOUNTERPROC = void(*)(NVNcommandBuffer*, NVNcounterType)

using PFNNVNCOMMANDBUFFERREPORTVALUEPROC = void(*)(NVNcommandBuffer*, uint32_t, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERSETRENDERENABLEPROC = void(*)(NVNcommandBuffer*, NVNboolean)

using PFNNVNCOMMANDBUFFERSETRENDERENABLECONDITIONALPROC = void(*)(NVNcommandBuffer*, NVNconditionalRenderMode, NVNbufferAddress)

using PFNNVNCOMMANDBUFFERSETRENDERTARGETSPROC = void(*)(NVNcommandBuffer*, int, const NVNtexture*const*, const NVNtextureView*const*, const NVNtexture*, const NVNtextureView*)

using PFNNVNCOMMANDBUFFERDISCARDCOLORPROC = void(*)(NVNcommandBuffer*, int)

using PFNNVNCOMMANDBUFFERDISCARDDEPTHSTENCILPROC = void(*)(NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERDOWNSAMPLEPROC = void(*)(NVNcommandBuffer*, const NVNtexture*, const NVNtexture*)

using PFNNVNCOMMANDBUFFERTILEDDOWNSAMPLEPROC = void(*)(NVNcommandBuffer*, const NVNtexture*, const NVNtexture*)

using PFNNVNCOMMANDBUFFERDOWNSAMPLETEXTUREVIEWPROC = void(*)(NVNcommandBuffer*, const NVNtexture*, const NVNtextureView*, const NVNtexture*, const NVNtextureView*)

using PFNNVNCOMMANDBUFFERTILEDDOWNSAMPLETEXTUREVIEWPROC = void(*)(NVNcommandBuffer*, const NVNtexture*, const NVNtextureView*, const NVNtexture*, const NVNtextureView*)

using PFNNVNCOMMANDBUFFERBARRIERPROC = void(*)(NVNcommandBuffer*, int)

using PFNNVNCOMMANDBUFFERWAITSYNCPROC = void(*)(NVNcommandBuffer*, const NVNsync*)

using PFNNVNCOMMANDBUFFERFENCESYNCPROC = void(*)(NVNcommandBuffer*, NVNsync*, NVNsyncCondition, int)

using PFNNVNCOMMANDBUFFERSETTEXTUREPOOLPROC = void(*)(NVNcommandBuffer*, const NVNtexturePool*)

using PFNNVNCOMMANDBUFFERSETSAMPLERPOOLPROC = void(*)(NVNcommandBuffer*, const NVNsamplerPool*)

using PFNNVNCOMMANDBUFFERSETSHADERSCRATCHMEMORYPROC = void(*)(NVNcommandBuffer*, const NVNmemoryPool*, ptrdiff_t, size_t)

using PFNNVNCOMMANDBUFFERSAVEZCULLDATAPROC = void(*)(NVNcommandBuffer*, NVNbufferAddress, size_t)

using PFNNVNCOMMANDBUFFERRESTOREZCULLDATAPROC = void(*)(NVNcommandBuffer*, NVNbufferAddress, size_t)

using PFNNVNCOMMANDBUFFERSETCOPYROWSTRIDEPROC = void(*)(NVNcommandBuffer*, ptrdiff_t)

using PFNNVNCOMMANDBUFFERSETCOPYIMAGESTRIDEPROC = void(*)(NVNcommandBuffer*, ptrdiff_t)

using PFNNVNCOMMANDBUFFERGETCOPYROWSTRIDEPROC = ptrdiff_t(*)(const NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERGETCOPYIMAGESTRIDEPROC = ptrdiff_t(*)(const NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERDRAWTEXTUREPROC = void(*)(NVNcommandBuffer*, NVNtextureHandle, const NVNdrawTextureRegion*, const NVNdrawTextureRegion*)

using PFNNVNPROGRAMSETSUBROUTINELINKAGEPROC = NVNboolean(*)(NVNprogram*, int, const NVNsubroutineLinkageMapPtr*)

using PFNNVNCOMMANDBUFFERSETPROGRAMSUBROUTINESPROC = void(*)(NVNcommandBuffer*, NVNprogram*, NVNshaderStage, const int, const int, const int*)

using PFNNVNCOMMANDBUFFERBINDCOVERAGEMODULATIONTABLEPROC = void(*)(NVNcommandBuffer*, const float*)

using PFNNVNCOMMANDBUFFERRESOLVEDEPTHBUFFERPROC = void(*)(NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERPUSHDEBUGGROUPSTATICPROC = void(*)(NVNcommandBuffer*, uint32_t, const char*)

using PFNNVNCOMMANDBUFFERPUSHDEBUGGROUPDYNAMICPROC = void(*)(NVNcommandBuffer*, uint32_t, const char*)

using PFNNVNCOMMANDBUFFERPUSHDEBUGGROUPPROC = void(*)(NVNcommandBuffer*, uint32_t, const char*)

using PFNNVNCOMMANDBUFFERPOPDEBUGGROUPPROC = void(*)(NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERPOPDEBUGGROUPIDPROC = void(*)(NVNcommandBuffer*, uint32_t)

using PFNNVNCOMMANDBUFFERINSERTDEBUGMARKERSTATICPROC = void(*)(NVNcommandBuffer*, uint32_t, const char*)

using PFNNVNCOMMANDBUFFERINSERTDEBUGMARKERDYNAMICPROC = void(*)(NVNcommandBuffer*, uint32_t, const char*)

using PFNNVNCOMMANDBUFFERINSERTDEBUGMARKERPROC = void(*)(NVNcommandBuffer*, const char*)

using PFNNVNCOMMANDBUFFERGETMEMORYCALLBACKPROC = PFNNVNCOMMANDBUFFERMEMORYCALLBACKPROC(*)(const NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERGETMEMORYCALLBACKDATAPROC = void(*)(const NVNcommandBuffer*)

using PFNNVNCOMMANDBUFFERISRECORDINGPROC = NVNboolean(*)(const NVNcommandBuffer*)

using PFNNVNSYNCINITIALIZEPROC = NVNboolean(*)(NVNsync*, NVNdevice*)

using PFNNVNSYNCFINALIZEPROC = void(*)(NVNsync*)

using PFNNVNSYNCSETDEBUGLABELPROC = void(*)(NVNsync*, const char*)

using PFNNVNQUEUEFENCESYNCPROC = void(*)(NVNqueue*, NVNsync*, NVNsyncCondition, int)

using PFNNVNSYNCWAITPROC = NVNsyncWaitResult(*)(const NVNsync*, uint64_t)

using PFNNVNQUEUEWAITSYNCPROC = NVNboolean(*)(NVNqueue*, const NVNsync*)

using PFNNVNEVENTBUILDERSETDEFAULTSPROC = void(*)(NVNeventBuilder*)

using PFNNVNEVENTBUILDERSETSTORAGEPROC = void(*)(NVNeventBuilder*, const NVNmemoryPool*, int64_t)

using PFNNVNEVENTINITIALIZEPROC = NVNboolean(*)(NVNevent*, const NVNeventBuilder*)

using PFNNVNEVENTFINALIZEPROC = void(*)(NVNevent*)

using PFNNVNEVENTGETVALUEPROC = uint32_t(*)(const NVNevent*)

using PFNNVNEVENTSIGNALPROC = void(*)(NVNevent*, NVNeventSignalMode, uint32_t)

using PFNNVNCOMMANDBUFFERWAITEVENTPROC = void(*)(NVNcommandBuffer*, const NVNevent*, NVNeventWaitMode, uint32_t)

using PFNNVNCOMMANDBUFFERSIGNALEVENTPROC = void(*)(NVNcommandBuffer*, const NVNevent*, NVNeventSignalMode, NVNeventSignalLocation, int, uint32_t)