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

Functions

static void nvnDeviceBuilderSetDefaults(NVNdeviceBuilder* builder)

static void nvnDeviceBuilderSetFlags(NVNdeviceBuilder* builder, int flags)

static auto nvnDeviceInitialize(NVNdevice* device, const NVNdeviceBuilder* builder) -> NVNboolean

static void nvnDeviceFinalize(NVNdevice* device)

static void nvnDeviceSetDebugLabel(NVNdevice* device, const char* label)

static auto nvnDeviceGetProcAddress(const NVNdevice* device, const char* s) -> PFNNVNGENERICFUNCPTRPROC

static void nvnDeviceGetInteger(const NVNdevice* device, NVNdeviceInfo pname, int* v)

static auto nvnDeviceGetCurrentTimestampInNanoseconds(const NVNdevice* device) -> uint64_t

static void nvnDeviceSetIntermediateShaderCache(NVNdevice* device, int i)

static auto nvnDeviceGetTextureHandle(const NVNdevice* device, int textureID, int samplerID) -> NVNtextureHandle

static auto nvnDeviceGetTexelFetchHandle(const NVNdevice* device, int textureID) -> NVNtextureHandle

static auto nvnDeviceGetImageHandle(const NVNdevice* device, int textureID) -> NVNimageHandle

static void nvnDeviceInstallDebugCallback(NVNdevice* device, const PFNNVNDEBUGCALLBACKPROC callback, void* callbackData, NVNboolean enable)

static auto nvnDeviceGenerateDebugDomainId(const NVNdevice* device, const char* s) -> NVNdebugDomainId

static void nvnDeviceSetWindowOriginMode(NVNdevice* device, NVNwindowOriginMode windowOriginMode)

static void nvnDeviceSetDepthMode(NVNdevice* device, NVNdepthMode depthMode)

static auto nvnDeviceRegisterFastClearColor(NVNdevice* device, const float* color, NVNformat format) -> NVNboolean

static auto nvnDeviceRegisterFastClearColori(NVNdevice* device, const int* color, NVNformat format) -> NVNboolean

static auto nvnDeviceRegisterFastClearColorui(NVNdevice* device, const uint32_t* color, NVNformat format) -> NVNboolean

static auto nvnDeviceRegisterFastClearDepth(NVNdevice* device, float f) -> NVNboolean

static auto nvnDeviceGetWindowOriginMode(const NVNdevice* device) -> NVNwindowOriginMode

static auto nvnDeviceGetDepthMode(const NVNdevice* device) -> NVNdepthMode

static auto nvnDeviceGetTimestampInNanoseconds(const NVNdevice* device, const NVNcounterData* counterData) -> uint64_t

static void nvnDeviceApplyDeferredFinalizes(NVNdevice* device, int i)

static void nvnDeviceFinalizeCommandHandle(NVNdevice* device, NVNcommandHandle handles)

static void nvnDeviceWalkDebugDatabase(const NVNdevice* device, NVNdebugObjectType debugObjectType, PFNNVNWALKDEBUGDATABASECALLBACKPROC callback, void* callbackData)

static auto nvnDeviceGetSeparateTextureHandle(const NVNdevice* device, int textureID) -> NVNseparateTextureHandle

static auto nvnDeviceGetSeparateSamplerHandle(const NVNdevice* device, int textureID) -> NVNseparateSamplerHandle

static auto nvnDeviceIsExternalDebuggerAttached(const NVNdevice* device) -> NVNboolean

static auto nvnQueueGetError(NVNqueue* queue, NVNqueueErrorInfo* info) -> NVNqueueGetErrorResult

static auto nvnQueueGetTotalCommandMemoryUsed(NVNqueue* queue) -> size_t

static auto nvnQueueGetTotalControlMemoryUsed(NVNqueue* queue) -> size_t

static auto nvnQueueGetTotalComputeMemoryUsed(NVNqueue* queue) -> size_t

static void nvnQueueResetMemoryUsageCounts(NVNqueue* queue)

static void nvnQueueBuilderSetDevice(NVNqueueBuilder* builder, NVNdevice* device)

static void nvnQueueBuilderSetDefaults(NVNqueueBuilder* builder)

static void nvnQueueBuilderSetFlags(NVNqueueBuilder* builder, int flags)

static void nvnQueueBuilderSetCommandMemorySize(NVNqueueBuilder* builder, size_t size)

static void nvnQueueBuilderSetComputeMemorySize(NVNqueueBuilder* builder, size_t size)

static void nvnQueueBuilderSetControlMemorySize(NVNqueueBuilder* builder, size_t size)

static auto nvnQueueBuilderGetQueueMemorySize(const NVNqueueBuilder* builder) -> size_t

static void nvnQueueBuilderSetQueueMemory(NVNqueueBuilder* builder, void* memory, size_t size)

static void nvnQueueBuilderSetCommandFlushThreshold(NVNqueueBuilder* builder, size_t size)

static auto nvnQueueInitialize(NVNqueue* queue, const NVNqueueBuilder* builder) -> NVNboolean

static void nvnQueueFinalize(NVNqueue* queue)

static void nvnQueueSetDebugLabel(NVNqueue* queue, const char* label)

static void nvnQueueSubmitCommands(NVNqueue* queue, int numCommands, const NVNcommandHandle* handles)

static void nvnQueueFlush(NVNqueue* queue)

static void nvnQueueFinish(NVNqueue* queue)

static void nvnQueuePresentTexture(NVNqueue* queue, NVNwindow* window, int textureIndex)

static auto nvnQueueAcquireTexture(NVNqueue* queue, NVNwindow* window, int* textureIndex) -> NVNqueueAcquireTextureResult

static void nvnWindowBuilderSetDevice(NVNwindowBuilder* builder, NVNdevice* device)

static void nvnWindowBuilderSetDefaults(NVNwindowBuilder* builder)

static void nvnWindowBuilderSetNativeWindow(NVNwindowBuilder* builder, NVNnativeWindow nativeWindow)

static void nvnWindowBuilderSetTextures(NVNwindowBuilder* builder, int numTextures, NVNtexture*const* textures)

static void nvnWindowBuilderSetPresentInterval(NVNwindowBuilder* builder, int presentInterval)

static auto nvnWindowBuilderGetNativeWindow(const NVNwindowBuilder* builder) -> NVNnativeWindow

static auto nvnWindowBuilderGetPresentInterval(const NVNwindowBuilder* builder) -> int

static auto nvnWindowInitialize(NVNwindow* window, const NVNwindowBuilder* builder) -> NVNboolean

static void nvnWindowFinalize(NVNwindow* window)

static void nvnWindowSetDebugLabel(NVNwindow* window, const char* label)

static auto nvnWindowAcquireTexture(NVNwindow* window, NVNsync* textureAvailableSync, int* textureIndex) -> NVNwindowAcquireTextureResult

static auto nvnWindowGetNativeWindow(const NVNwindow* window) -> NVNnativeWindow

static auto nvnWindowGetPresentInterval(const NVNwindow* window) -> int

static void nvnWindowSetPresentInterval(NVNwindow* window, int presentInterval)

static void nvnWindowSetCrop(NVNwindow* window, int x, int y, int w, int h)

static void nvnWindowGetCrop(const NVNwindow* window, NVNrectangle* rectangle)

static auto nvnProgramInitialize(NVNprogram* program, NVNdevice* device) -> NVNboolean

static void nvnProgramFinalize(NVNprogram* program)

static void nvnProgramSetDebugLabel(NVNprogram* program, const char* label)

static auto nvnProgramSetShaders(NVNprogram* program, int count, const NVNshaderData* stageData) -> NVNboolean

static void nvnMemoryPoolBuilderSetDevice(NVNmemoryPoolBuilder* builder, NVNdevice* device)

static void nvnMemoryPoolBuilderSetDefaults(NVNmemoryPoolBuilder* builder)

static void nvnMemoryPoolBuilderSetStorage(NVNmemoryPoolBuilder* builder, void* memory, size_t size)

static void nvnMemoryPoolBuilderSetFlags(NVNmemoryPoolBuilder* builder, int flags)

static void nvnMemoryPoolBuilderGetMemory(const NVNmemoryPoolBuilder* builder)

static auto nvnMemoryPoolBuilderGetSize(const NVNmemoryPoolBuilder* builder) -> size_t

static auto nvnMemoryPoolBuilderGetFlags(const NVNmemoryPoolBuilder* builder) -> NVNmemoryPoolFlags

static auto nvnMemoryPoolInitialize(NVNmemoryPool* pool, const NVNmemoryPoolBuilder* builder) -> NVNboolean

static void nvnMemoryPoolSetDebugLabel(NVNmemoryPool* pool, const char* label)

static void nvnMemoryPoolFinalize(NVNmemoryPool* pool)

static auto nvnMemoryPoolMap(const NVNmemoryPool* pool) -> void*

static void nvnMemoryPoolFlushMappedRange(const NVNmemoryPool* pool, ptrdiff_t offset, size_t size)

static void nvnMemoryPoolInvalidateMappedRange(const NVNmemoryPool* pool, ptrdiff_t offset, size_t size)

static auto nvnMemoryPoolGetBufferAddress(const NVNmemoryPool* pool) -> NVNbufferAddress

static auto nvnMemoryPoolMapVirtual(NVNmemoryPool* pool, int numRequests, const NVNmappingRequest* requests) -> NVNboolean

static auto nvnMemoryPoolGetSize(const NVNmemoryPool* pool) -> size_t

static auto nvnMemoryPoolGetFlags(const NVNmemoryPool* pool) -> NVNmemoryPoolFlags

static auto nvnTexturePoolInitialize(NVNtexturePool* texturePool, const NVNmemoryPool* memoryPool, ptrdiff_t offset, int numDescriptors) -> NVNboolean

static void nvnTexturePoolSetDebugLabel(NVNtexturePool* pool, const char* label)

static void nvnTexturePoolFinalize(NVNtexturePool* pool)

static void nvnTexturePoolRegisterTexture(const NVNtexturePool* pool, int id, const NVNtexture* texture, const NVNtextureView* view)

static void nvnTexturePoolRegisterImage(const NVNtexturePool* pool, int id, const NVNtexture* texture, const NVNtextureView* view)

static auto nvnTexturePoolGetMemoryPool(const NVNtexturePool* pool) -> const NVNmemoryPool*

static auto nvnTexturePoolGetMemoryOffset(const NVNtexturePool* pool) -> ptrdiff_t

static auto nvnTexturePoolGetSize(const NVNtexturePool* pool) -> int

static auto nvnSamplerPoolInitialize(NVNsamplerPool* samplerPool, const NVNmemoryPool* memoryPool, ptrdiff_t offset, int numDescriptors) -> NVNboolean

static void nvnSamplerPoolSetDebugLabel(NVNsamplerPool* pool, const char* label)

static void nvnSamplerPoolFinalize(NVNsamplerPool* pool)

static void nvnSamplerPoolRegisterSampler(const NVNsamplerPool* pool, int id, const NVNsampler* sampler)

static void nvnSamplerPoolRegisterSamplerBuilder(const NVNsamplerPool* pool, int id, const NVNsamplerBuilder* builder)

static auto nvnSamplerPoolGetMemoryPool(const NVNsamplerPool* pool) -> const NVNmemoryPool*

static auto nvnSamplerPoolGetMemoryOffset(const NVNsamplerPool* pool) -> ptrdiff_t

static auto nvnSamplerPoolGetSize(const NVNsamplerPool* pool) -> int

static void nvnBufferBuilderSetDevice(NVNbufferBuilder* builder, NVNdevice* device)

static void nvnBufferBuilderSetDefaults(NVNbufferBuilder* builder)

static void nvnBufferBuilderSetStorage(NVNbufferBuilder* builder, NVNmemoryPool* pool, ptrdiff_t offset, size_t size)

static auto nvnBufferBuilderGetMemoryPool(const NVNbufferBuilder* builder) -> NVNmemoryPool

static auto nvnBufferBuilderGetMemoryOffset(const NVNbufferBuilder* builder) -> ptrdiff_t

static auto nvnBufferBuilderGetSize(const NVNbufferBuilder* builder) -> size_t

static auto nvnBufferInitialize(NVNbuffer* buffer, const NVNbufferBuilder* builder) -> NVNboolean

static void nvnBufferSetDebugLabel(NVNbuffer* buffer, const char* label)

static void nvnBufferFinalize(NVNbuffer* buffer)

static auto nvnBufferMap(const NVNbuffer* buffer) -> void*

static auto nvnBufferGetAddress(const NVNbuffer* buffer) -> NVNbufferAddress

static void nvnBufferFlushMappedRange(const NVNbuffer* buffer, ptrdiff_t offset, size_t size)

static void nvnBufferInvalidateMappedRange(const NVNbuffer* buffer, ptrdiff_t offset, size_t size)

static auto nvnBufferGetMemoryPool(const NVNbuffer* buffer) -> NVNmemoryPool*

static auto nvnBufferGetMemoryOffset(const NVNbuffer* buffer) -> ptrdiff_t

static auto nvnBufferGetSize(const NVNbuffer* buffer) -> size_t

static auto nvnBufferGetDebugID(const NVNbuffer* buffer) -> uint64_t

static void nvnTextureBuilderSetDevice(NVNtextureBuilder* builder, NVNdevice* device)

static void nvnTextureBuilderSetDefaults(NVNtextureBuilder* builder)

static void nvnTextureBuilderSetFlags(NVNtextureBuilder* builder, int flags)

static void nvnTextureBuilderSetTarget(NVNtextureBuilder* builder, NVNtextureTarget target)

static void nvnTextureBuilderSetWidth(NVNtextureBuilder* builder, int width)

static void nvnTextureBuilderSetHeight(NVNtextureBuilder* builder, int height)

static void nvnTextureBuilderSetDepth(NVNtextureBuilder* builder, int depth)

static void nvnTextureBuilderSetSize1D(NVNtextureBuilder* builder, int size)

static void nvnTextureBuilderSetSize2D(NVNtextureBuilder* builder, int width, int height)

static void nvnTextureBuilderSetSize3D(NVNtextureBuilder* builder, int width, int height, int depth)

static void nvnTextureBuilderSetLevels(NVNtextureBuilder* builder, int numLevels)

static void nvnTextureBuilderSetFormat(NVNtextureBuilder* builder, NVNformat format)

static void nvnTextureBuilderSetSamples(NVNtextureBuilder* builder, int samples)

static void nvnTextureBuilderSetSwizzle(NVNtextureBuilder* builder, NVNtextureSwizzle r, NVNtextureSwizzle g, NVNtextureSwizzle b, NVNtextureSwizzle a)

static void nvnTextureBuilderSetDepthStencilMode(NVNtextureBuilder* builder, NVNtextureDepthStencilMode mode)

static auto nvnTextureBuilderGetStorageSize(const NVNtextureBuilder* builder) -> size_t

static auto nvnTextureBuilderGetStorageAlignment(const NVNtextureBuilder* builder) -> size_t

static void nvnTextureBuilderSetStorage(NVNtextureBuilder* builder, NVNmemoryPool* pool, ptrdiff_t offset)

static void nvnTextureBuilderSetPackagedTextureData(NVNtextureBuilder* builder, const void* data)

static void nvnTextureBuilderSetPackagedTextureLayout(NVNtextureBuilder* builder, const NVNpackagedTextureLayout* layout)

static void nvnTextureBuilderSetStride(NVNtextureBuilder* builder, ptrdiff_t stride)

static void nvnTextureBuilderSetGLTextureName(NVNtextureBuilder* builder, uint32_t name)

static auto nvnTextureBuilderGetStorageClass(const NVNtextureBuilder* builder) -> NVNstorageClass

static auto nvnTextureBuilderGetFlags(const NVNtextureBuilder* builder) -> NVNtextureFlags

static auto nvnTextureBuilderGetTarget(const NVNtextureBuilder* builder) -> NVNtextureTarget

static auto nvnTextureBuilderGetWidth(const NVNtextureBuilder* builder) -> int

static auto nvnTextureBuilderGetHeight(const NVNtextureBuilder* builder) -> int

static auto nvnTextureBuilderGetDepth(const NVNtextureBuilder* builder) -> int

static auto nvnTextureBuilderGetLevels(const NVNtextureBuilder* builder) -> int

static auto nvnTextureBuilderGetFormat(const NVNtextureBuilder* builder) -> NVNformat

static auto nvnTextureBuilderGetSamples(const NVNtextureBuilder* builder) -> int

static void nvnTextureBuilderGetSwizzle(const NVNtextureBuilder* builder, NVNtextureSwizzle* r, NVNtextureSwizzle* g, NVNtextureSwizzle* b, NVNtextureSwizzle* a)

static auto nvnTextureBuilderGetDepthStencilMode(const NVNtextureBuilder* builder) -> NVNtextureDepthStencilMode

static auto nvnTextureBuilderGetPackagedTextureData(const NVNtextureBuilder* builder) -> const void*

static auto nvnTextureBuilderGetStride(const NVNtextureBuilder* builder) -> ptrdiff_t

static void nvnTextureBuilderGetSparseTileLayout(const NVNtextureBuilder* builder, NVNtextureSparseTileLayout* layout)

static auto nvnTextureBuilderGetGLTextureName(const NVNtextureBuilder* builder) -> uint32_t

static auto nvnTextureBuilderGetZCullStorageSize(const NVNtextureBuilder* builder) -> size_t

static auto nvnTextureBuilderGetMemoryPool(const NVNtextureBuilder* builder) -> NVNmemoryPool

static auto nvnTextureBuilderGetMemoryOffset(const NVNtextureBuilder* builder) -> ptrdiff_t

static void nvnTextureViewSetDefaults(NVNtextureView* view)

static void nvnTextureViewSetLevels(NVNtextureView* view, int baseLevel, int numLevels)

static void nvnTextureViewSetLayers(NVNtextureView* view, int minLayer, int numLayers)

static void nvnTextureViewSetFormat(NVNtextureView* view, NVNformat format)

static void nvnTextureViewSetSwizzle(NVNtextureView* view, NVNtextureSwizzle r, NVNtextureSwizzle g, NVNtextureSwizzle b, NVNtextureSwizzle a)

static void nvnTextureViewSetDepthStencilMode(NVNtextureView* view, NVNtextureDepthStencilMode mode)

static void nvnTextureViewSetTarget(NVNtextureView* view, NVNtextureTarget target)

static auto nvnTextureViewGetLevels(const NVNtextureView* view, int* baseLevel, int* numLevels) -> NVNboolean

static auto nvnTextureViewGetLayers(const NVNtextureView* view, int* minLayer, int* numLayers) -> NVNboolean

static auto nvnTextureViewGetFormat(const NVNtextureView* view, NVNformat* format) -> NVNboolean

static auto nvnTextureViewGetSwizzle(const NVNtextureView* view, NVNtextureSwizzle* r, NVNtextureSwizzle* g, NVNtextureSwizzle* b, NVNtextureSwizzle* a) -> NVNboolean

static auto nvnTextureViewGetDepthStencilMode(const NVNtextureView* view, NVNtextureDepthStencilMode* mode) -> NVNboolean

static auto nvnTextureViewGetTarget(const NVNtextureView* view, NVNtextureTarget* target) -> NVNboolean

static auto nvnTextureViewCompare(const NVNtextureView* view1, const NVNtextureView* view2) -> NVNboolean

static auto nvnTextureInitialize(NVNtexture* texture, const NVNtextureBuilder* builder) -> NVNboolean

static auto nvnTextureGetZCullStorageSize(const NVNtexture* texture) -> size_t

static void nvnTextureFinalize(NVNtexture* texture)

static void nvnTextureSetDebugLabel(NVNtexture* texture, const char* label)

static auto nvnTextureGetStorageClass(const NVNtexture* texture) -> NVNstorageClass

static auto nvnTextureGetViewOffset(const NVNtexture* texture, const NVNtextureView* view) -> ptrdiff_t

static auto nvnTextureGetFlags(const NVNtexture* texture) -> NVNtextureFlags

static auto nvnTextureGetTarget(const NVNtexture* texture) -> NVNtextureTarget

static auto nvnTextureGetWidth(const NVNtexture* texture) -> int

static auto nvnTextureGetHeight(const NVNtexture* texture) -> int

static auto nvnTextureGetDepth(const NVNtexture* texture) -> int

static auto nvnTextureGetLevels(const NVNtexture* texture) -> int

static auto nvnTextureGetFormat(const NVNtexture* texture) -> NVNformat

static auto nvnTextureGetSamples(const NVNtexture* texture) -> int

static void nvnTextureGetSwizzle(const NVNtexture* texture, NVNtextureSwizzle* r, NVNtextureSwizzle* g, NVNtextureSwizzle* b, NVNtextureSwizzle* a)

static auto nvnTextureGetDepthStencilMode(const NVNtexture* texture) -> NVNtextureDepthStencilMode

static auto nvnTextureGetStride(const NVNtexture* texture) -> ptrdiff_t

static auto nvnTextureGetTextureAddress(const NVNtexture* texture) -> NVNtextureAddress

static void nvnTextureGetSparseTileLayout(const NVNtexture* texture, NVNtextureSparseTileLayout* layout)

static void nvnTextureWriteTexels(const NVNtexture* texture, const NVNtextureView* view, const NVNcopyRegion* region, const void* p)

static void nvnTextureWriteTexelsStrided(const NVNtexture* texture, const NVNtextureView* view, const NVNcopyRegion* region, const void* p, ptrdiff_t o1, ptrdiff_t o2)

static void nvnTextureReadTexels(const NVNtexture* texture, const NVNtextureView* view, const NVNcopyRegion* region, void* p)

static void nvnTextureReadTexelsStrided(const NVNtexture* texture, const NVNtextureView* view, const NVNcopyRegion* region, void* p, ptrdiff_t o1, ptrdiff_t o2)

static void nvnTextureFlushTexels(const NVNtexture* texture, const NVNtextureView* view, const NVNcopyRegion* region)

static void nvnTextureInvalidateTexels(const NVNtexture* texture, const NVNtextureView* view, const NVNcopyRegion* region)

static auto nvnTextureGetMemoryPool(const NVNtexture* texture) -> NVNmemoryPool

static auto nvnTextureGetMemoryOffset(const NVNtexture* texture) -> ptrdiff_t

static auto nvnTextureGetStorageSize(const NVNtexture* texture) -> int

static auto nvnTextureCompare(const NVNtexture* texture1, const NVNtexture* texture2) -> NVNboolean

static auto nvnTextureGetDebugID(const NVNtexture* texture) -> uint64_t

static void nvnSamplerBuilderSetDevice(NVNsamplerBuilder* builder, NVNdevice* device)

static void nvnSamplerBuilderSetDefaults(NVNsamplerBuilder* builder)

static void nvnSamplerBuilderSetMinMagFilter(NVNsamplerBuilder* builder, NVNminFilter min, NVNmagFilter mag)

static void nvnSamplerBuilderSetWrapMode(NVNsamplerBuilder* builder, NVNwrapMode s, NVNwrapMode t, NVNwrapMode r)

static void nvnSamplerBuilderSetLodClamp(NVNsamplerBuilder* builder, float min, float max)

static void nvnSamplerBuilderSetLodBias(NVNsamplerBuilder* builder, float bias)

static void nvnSamplerBuilderSetCompare(NVNsamplerBuilder* builder, NVNcompareMode mode, NVNcompareFunc func)

static void nvnSamplerBuilderSetBorderColor(NVNsamplerBuilder* builder, const float* borderColor)

static void nvnSamplerBuilderSetBorderColori(NVNsamplerBuilder* builder, const int* borderColor)

static void nvnSamplerBuilderSetBorderColorui(NVNsamplerBuilder* builder, const uint32_t* borderColor)

static void nvnSamplerBuilderSetMaxAnisotropy(NVNsamplerBuilder* builder, float maxAniso)

static void nvnSamplerBuilderSetReductionFilter(NVNsamplerBuilder* builder, NVNsamplerReduction filter)

static void nvnSamplerBuilderSetLodSnap(NVNsamplerBuilder* builder, float f)

static void nvnSamplerBuilderGetMinMagFilter(const NVNsamplerBuilder* builder, NVNminFilter* min, NVNmagFilter* mag)

static void nvnSamplerBuilderGetWrapMode(const NVNsamplerBuilder* builder, NVNwrapMode* s, NVNwrapMode* t, NVNwrapMode* r)

static void nvnSamplerBuilderGetLodClamp(const NVNsamplerBuilder* builder, float* min, float* max)

static auto nvnSamplerBuilderGetLodBias(const NVNsamplerBuilder* builder) -> float

static void nvnSamplerBuilderGetCompare(const NVNsamplerBuilder* builder, NVNcompareMode* mode, NVNcompareFunc* func)

static void nvnSamplerBuilderGetBorderColor(const NVNsamplerBuilder* builder, float* borderColor)

static void nvnSamplerBuilderGetBorderColori(const NVNsamplerBuilder* builder, int* borderColor)

static void nvnSamplerBuilderGetBorderColorui(const NVNsamplerBuilder* builder, uint32_t* borderColor)

static auto nvnSamplerBuilderGetMaxAnisotropy(const NVNsamplerBuilder* builder) -> float

static auto nvnSamplerBuilderGetReductionFilter(const NVNsamplerBuilder* builder) -> NVNsamplerReduction

static auto nvnSamplerBuilderGetLodSnap(const NVNsamplerBuilder* builder) -> float

static auto nvnSamplerInitialize(NVNsampler* sampler, const NVNsamplerBuilder* builder) -> NVNboolean

static void nvnSamplerFinalize(NVNsampler* sampler)

static void nvnSamplerSetDebugLabel(NVNsampler* sampler, const char* label)

static void nvnSamplerGetMinMagFilter(const NVNsampler* sampler, NVNminFilter* min, NVNmagFilter* mag)

static void nvnSamplerGetWrapMode(const NVNsampler* sampler, NVNwrapMode* s, NVNwrapMode* t, NVNwrapMode* r)

static void nvnSamplerGetLodClamp(const NVNsampler* sampler, float* min, float* max)

static auto nvnSamplerGetLodBias(const NVNsampler* sampler) -> float

static void nvnSamplerGetCompare(const NVNsampler* sampler, NVNcompareMode* mode, NVNcompareFunc* func)

static void nvnSamplerGetBorderColor(const NVNsampler* sampler, float* borderColor)

static void nvnSamplerGetBorderColori(const NVNsampler* sampler, int* borderColor)

static void nvnSamplerGetBorderColorui(const NVNsampler* sampler, uint32_t* borderColor)

static auto nvnSamplerGetMaxAnisotropy(const NVNsampler* sampler) -> float

static auto nvnSamplerGetReductionFilter(const NVNsampler* sampler) -> NVNsamplerReduction

static auto nvnSamplerCompare(const NVNsampler* sampler1, const NVNsampler* sampler2) -> NVNboolean

static auto nvnSamplerGetDebugID(const NVNsampler* sampler) -> uint64_t

static void nvnBlendStateSetDefaults(NVNblendState* blend)

static void nvnBlendStateSetBlendTarget(NVNblendState* blend, int target)

static void nvnBlendStateSetBlendFunc(NVNblendState* blend, NVNblendFunc srcFunc, NVNblendFunc dstFunc, NVNblendFunc srcFuncAlpha, NVNblendFunc dstFuncAlpha)

static void nvnBlendStateSetBlendEquation(NVNblendState* blend, NVNblendEquation modeRGB, NVNblendEquation modeAlpha)

static void nvnBlendStateSetAdvancedMode(NVNblendState* blend, NVNblendAdvancedMode mode)

static void nvnBlendStateSetAdvancedOverlap(NVNblendState* blend, NVNblendAdvancedOverlap overlap)

static void nvnBlendStateSetAdvancedPremultipliedSrc(NVNblendState* blend, NVNboolean b)

static void nvnBlendStateSetAdvancedNormalizedDst(NVNblendState* blend, NVNboolean b)

static auto nvnBlendStateGetBlendTarget(const NVNblendState* blend) -> int

static void nvnBlendStateGetBlendFunc(const NVNblendState* blend, NVNblendFunc* srcFunc, NVNblendFunc* dstFunc, NVNblendFunc* srcFuncAlpha, NVNblendFunc* dstFuncAlpha)

static void nvnBlendStateGetBlendEquation(const NVNblendState* blend, NVNblendEquation* modeRGB, NVNblendEquation* modeAlpha)

static auto nvnBlendStateGetAdvancedMode(const NVNblendState* blend) -> NVNblendAdvancedMode

static auto nvnBlendStateGetAdvancedOverlap(const NVNblendState* blend) -> NVNblendAdvancedOverlap

static auto nvnBlendStateGetAdvancedPremultipliedSrc(const NVNblendState* blend) -> NVNboolean

static auto nvnBlendStateGetAdvancedNormalizedDst(const NVNblendState* blend) -> NVNboolean

static void nvnColorStateSetDefaults(NVNcolorState* color)

static void nvnColorStateSetBlendEnable(NVNcolorState* color, int index, NVNboolean enable)

static void nvnColorStateSetLogicOp(NVNcolorState* color, NVNlogicOp logicOp)

static void nvnColorStateSetAlphaTest(NVNcolorState* color, NVNalphaFunc alphaFunc)

static auto nvnColorStateGetBlendEnable(const NVNcolorState* color, int index) -> NVNboolean

static auto nvnColorStateGetLogicOp(const NVNcolorState* color) -> NVNlogicOp

static auto nvnColorStateGetAlphaTest(const NVNcolorState* color) -> NVNalphaFunc

static void nvnChannelMaskStateSetDefaults(NVNchannelMaskState* channelMask)

static void nvnChannelMaskStateSetChannelMask(NVNchannelMaskState* channelMask, int index, NVNboolean r, NVNboolean g, NVNboolean b, NVNboolean a)

static void nvnChannelMaskStateGetChannelMask(const NVNchannelMaskState* channelMask, int index, NVNboolean* r, NVNboolean* g, NVNboolean* b, NVNboolean* a)

static void nvnMultisampleStateSetDefaults(NVNmultisampleState* multisample)

static void nvnMultisampleStateSetMultisampleEnable(NVNmultisampleState* multisample, NVNboolean enable)

static void nvnMultisampleStateSetSamples(NVNmultisampleState* multisample, int samples)

static void nvnMultisampleStateSetAlphaToCoverageEnable(NVNmultisampleState* multisample, NVNboolean enable)

static void nvnMultisampleStateSetAlphaToCoverageDither(NVNmultisampleState* multisample, NVNboolean enable)

static auto nvnMultisampleStateGetMultisampleEnable(const NVNmultisampleState* multisample) -> NVNboolean

static auto nvnMultisampleStateGetSamples(const NVNmultisampleState* multisample) -> int

static auto nvnMultisampleStateGetAlphaToCoverageEnable(const NVNmultisampleState* multisample) -> NVNboolean

static auto nvnMultisampleStateGetAlphaToCoverageDither(const NVNmultisampleState* multisample) -> NVNboolean

static void nvnMultisampleStateSetRasterSamples(NVNmultisampleState* multisample, int samples)

static auto nvnMultisampleStateGetRasterSamples(NVNmultisampleState* multisample) -> int

static void nvnMultisampleStateSetCoverageModulationMode(NVNmultisampleState* multisample, NVNcoverageModulationMode mode)

static auto nvnMultisampleStateGetCoverageModulationMode(const NVNmultisampleState* multisample) -> NVNcoverageModulationMode

static void nvnMultisampleStateSetCoverageToColorEnable(NVNmultisampleState* multisample, NVNboolean enable)

static auto nvnMultisampleStateGetCoverageToColorEnable(const NVNmultisampleState* multisample) -> NVNboolean

static void nvnMultisampleStateSetCoverageToColorOutput(NVNmultisampleState* multisample, int i)

static auto nvnMultisampleStateGetCoverageToColorOutput(const NVNmultisampleState* multisample) -> int

static void nvnMultisampleStateSetSampleLocationsEnable(NVNmultisampleState* multisample, NVNboolean enable)

static auto nvnMultisampleStateGetSampleLocationsEnable(const NVNmultisampleState* multisample) -> NVNboolean

static void nvnMultisampleStateGetSampleLocationsGrid(NVNmultisampleState* multisample, int* w, int* h)

static void nvnMultisampleStateSetSampleLocationsGridEnable(NVNmultisampleState* multisample, NVNboolean enable)

static auto nvnMultisampleStateGetSampleLocationsGridEnable(const NVNmultisampleState* multisample) -> NVNboolean

static void nvnMultisampleStateSetSampleLocations(NVNmultisampleState* multisample, int i1, int i2, const float* f)

static void nvnPolygonStateSetDefaults(NVNpolygonState* polygon)

static void nvnPolygonStateSetCullFace(NVNpolygonState* polygon, NVNface face)

static void nvnPolygonStateSetFrontFace(NVNpolygonState* polygon, NVNfrontFace face)

static void nvnPolygonStateSetPolygonMode(NVNpolygonState* polygon, NVNpolygonMode polygonMode)

static void nvnPolygonStateSetPolygonOffsetEnables(NVNpolygonState* polygon, int enables)

static auto nvnPolygonStateGetCullFace(const NVNpolygonState* polygon) -> NVNface

static auto nvnPolygonStateGetFrontFace(const NVNpolygonState* polygon) -> NVNfrontFace

static auto nvnPolygonStateGetPolygonMode(const NVNpolygonState* polygon) -> NVNpolygonMode

static auto nvnPolygonStateGetPolygonOffsetEnables(const NVNpolygonState* polygon) -> NVNpolygonOffsetEnable

static void nvnDepthStencilStateSetDefaults(NVNdepthStencilState* depthStencil)

static void nvnDepthStencilStateSetDepthTestEnable(NVNdepthStencilState* depthStencil, NVNboolean enable)

static void nvnDepthStencilStateSetDepthWriteEnable(NVNdepthStencilState* depthStencil, NVNboolean enable)

static void nvnDepthStencilStateSetDepthFunc(NVNdepthStencilState* depthStencil, NVNdepthFunc func)

static void nvnDepthStencilStateSetStencilTestEnable(NVNdepthStencilState* depthStencil, NVNboolean enable)

static void nvnDepthStencilStateSetStencilFunc(NVNdepthStencilState* depthStencil, NVNface faces, NVNstencilFunc func)

static void nvnDepthStencilStateSetStencilOp(NVNdepthStencilState* depthStencil, NVNface faces, NVNstencilOp fail, NVNstencilOp depthFail, NVNstencilOp depthPass)

static auto nvnDepthStencilStateGetDepthTestEnable(const NVNdepthStencilState* depthStencil) -> NVNboolean

static auto nvnDepthStencilStateGetDepthWriteEnable(const NVNdepthStencilState* depthStencil) -> NVNboolean

static auto nvnDepthStencilStateGetDepthFunc(const NVNdepthStencilState* depthStencil) -> NVNdepthFunc

static auto nvnDepthStencilStateGetStencilTestEnable(const NVNdepthStencilState* depthStencil) -> NVNboolean

static auto nvnDepthStencilStateGetStencilFunc(const NVNdepthStencilState* depthStencil, NVNface faces) -> NVNstencilFunc

static void nvnDepthStencilStateGetStencilOp(const NVNdepthStencilState* depthStencil, NVNface faces, NVNstencilOp* fail, NVNstencilOp* depthFail, NVNstencilOp* depthPass)

static void nvnVertexAttribStateSetDefaults(NVNvertexAttribState* attrib)

static void nvnVertexAttribStateSetFormat(NVNvertexAttribState* attrib, NVNformat format, ptrdiff_t relativeOffset)

static void nvnVertexAttribStateSetStreamIndex(NVNvertexAttribState* attrib, int streamIndex)

static void nvnVertexAttribStateGetFormat(const NVNvertexAttribState* attrib, NVNformat* format, ptrdiff_t* relativeOffset)

static auto nvnVertexAttribStateGetStreamIndex(const NVNvertexAttribState* attrib) -> int

static void nvnVertexStreamStateSetDefaults(NVNvertexStreamState* stream)

static void nvnVertexStreamStateSetStride(NVNvertexStreamState* stream, ptrdiff_t stride)

static void nvnVertexStreamStateSetDivisor(NVNvertexStreamState* stream, int divisor)

static auto nvnVertexStreamStateGetStride(const NVNvertexStreamState* stream) -> ptrdiff_t

static auto nvnVertexStreamStateGetDivisor(const NVNvertexStreamState* stream) -> int

static auto nvnCommandBufferInitialize(NVNcommandBuffer* cmdBuf, NVNdevice* device) -> NVNboolean

static void nvnCommandBufferFinalize(NVNcommandBuffer* cmdBuf)

static void nvnCommandBufferSetDebugLabel(NVNcommandBuffer* cmdBuf, const char* label)

static void nvnCommandBufferSetMemoryCallback(NVNcommandBuffer* cmdBuf, PFNNVNCOMMANDBUFFERMEMORYCALLBACKPROC callback)

static void nvnCommandBufferSetMemoryCallbackData(NVNcommandBuffer* cmdBuf, void* callbackData)

static void nvnCommandBufferAddCommandMemory(NVNcommandBuffer* cmdBuf, const NVNmemoryPool* pool, ptrdiff_t offset, size_t size)

static void nvnCommandBufferAddControlMemory(NVNcommandBuffer* cmdBuf, void* memory, size_t size)

static auto nvnCommandBufferGetCommandMemorySize(const NVNcommandBuffer* cmdBuf) -> size_t

static auto nvnCommandBufferGetCommandMemoryUsed(const NVNcommandBuffer* cmdBuf) -> size_t

static auto nvnCommandBufferGetCommandMemoryFree(const NVNcommandBuffer* cmdBuf) -> size_t

static auto nvnCommandBufferGetControlMemorySize(const NVNcommandBuffer* cmdBuf) -> size_t

static auto nvnCommandBufferGetControlMemoryUsed(const NVNcommandBuffer* cmdBuf) -> size_t

static auto nvnCommandBufferGetControlMemoryFree(const NVNcommandBuffer* cmdBuf) -> size_t

static void nvnCommandBufferBeginRecording(NVNcommandBuffer* cmdBuf)

static auto nvnCommandBufferEndRecording(NVNcommandBuffer* cmdBuf) -> NVNcommandHandle

static void nvnCommandBufferCallCommands(NVNcommandBuffer* cmdBuf, int numCommands, const NVNcommandHandle* handles)

static void nvnCommandBufferCopyCommands(NVNcommandBuffer* cmdBuf, int numCommands, const NVNcommandHandle* handles)

static void nvnCommandBufferBindBlendState(NVNcommandBuffer* cmdBuf, const NVNblendState* blend)

static void nvnCommandBufferBindChannelMaskState(NVNcommandBuffer* cmdBuf, const NVNchannelMaskState* channelMask)

static void nvnCommandBufferBindColorState(NVNcommandBuffer* cmdBuf, const NVNcolorState* color)

static void nvnCommandBufferBindMultisampleState(NVNcommandBuffer* cmdBuf, const NVNmultisampleState* multisample)

static void nvnCommandBufferBindPolygonState(NVNcommandBuffer* cmdBuf, const NVNpolygonState* polygon)

static void nvnCommandBufferBindDepthStencilState(NVNcommandBuffer* cmdBuf, const NVNdepthStencilState* depthStencil)

static void nvnCommandBufferBindVertexAttribState(NVNcommandBuffer* cmdBuf, int numAttribs, const NVNvertexAttribState* attribs)

static void nvnCommandBufferBindVertexStreamState(NVNcommandBuffer* cmdBuf, int numStreams, const NVNvertexStreamState* streams)

static void nvnCommandBufferBindProgram(NVNcommandBuffer* cmdBuf, const NVNprogram* program, int stages)

static void nvnCommandBufferBindVertexBuffer(NVNcommandBuffer* cmdBuf, int index, NVNbufferAddress buffer, size_t size)

static void nvnCommandBufferBindVertexBuffers(NVNcommandBuffer* cmdBuf, int first, int count, const NVNbufferRange* buffers)

static void nvnCommandBufferBindUniformBuffer(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int index, NVNbufferAddress buffer, size_t size)

static void nvnCommandBufferBindUniformBuffers(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int first, int count, const NVNbufferRange* buffers)

static void nvnCommandBufferBindTransformFeedbackBuffer(NVNcommandBuffer* cmdBuf, int index, NVNbufferAddress buffer, size_t size)

static void nvnCommandBufferBindTransformFeedbackBuffers(NVNcommandBuffer* cmdBuf, int first, int count, const NVNbufferRange* buffers)

static void nvnCommandBufferBindStorageBuffer(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int index, NVNbufferAddress buffer, size_t size)

static void nvnCommandBufferBindStorageBuffers(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int first, int count, const NVNbufferRange* buffers)

static void nvnCommandBufferBindTexture(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int index, NVNtextureHandle texture)

static void nvnCommandBufferBindTextures(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int first, int count, const NVNtextureHandle* textures)

static void nvnCommandBufferBindImage(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int index, NVNimageHandle image)

static void nvnCommandBufferBindImages(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int first, int count, const NVNimageHandle* images)

static void nvnCommandBufferSetPatchSize(NVNcommandBuffer* cmdBuf, int i)

static void nvnCommandBufferSetInnerTessellationLevels(NVNcommandBuffer* cmdBuf, const float* f)

static void nvnCommandBufferSetOuterTessellationLevels(NVNcommandBuffer* cmdBuf, const float* f)

static void nvnCommandBufferSetPrimitiveRestart(NVNcommandBuffer* cmdBuf, NVNboolean b, int i)

static void nvnCommandBufferBeginTransformFeedback(NVNcommandBuffer* cmdBuf, NVNbufferAddress buffer)

static void nvnCommandBufferEndTransformFeedback(NVNcommandBuffer* cmdBuf, NVNbufferAddress buffer)

static void nvnCommandBufferPauseTransformFeedback(NVNcommandBuffer* cmdBuf, NVNbufferAddress buffer)

static void nvnCommandBufferResumeTransformFeedback(NVNcommandBuffer* cmdBuf, NVNbufferAddress buffer)

static void nvnCommandBufferDrawTransformFeedback(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode, NVNbufferAddress buffer)

static void nvnCommandBufferDrawArrays(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode, int first, int count)

static void nvnCommandBufferDrawElements(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode, NVNindexType type, int count, NVNbufferAddress indexBuffer)

static void nvnCommandBufferDrawElementsBaseVertex(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode, NVNindexType type, int count, NVNbufferAddress indexBuffer, int baseVertex)

static void nvnCommandBufferDrawArraysInstanced(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode, int first, int count, int baseInstance, int instanceCount)

static void nvnCommandBufferDrawElementsInstanced(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode, NVNindexType type, int count, NVNbufferAddress indexBuffer, int baseVertex, int baseInstance, int instanceCount)

static void nvnCommandBufferDrawArraysIndirect(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode, NVNbufferAddress buffer)

static void nvnCommandBufferDrawElementsIndirect(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode, NVNindexType type, NVNbufferAddress buffer1, NVNbufferAddress buffer2)

static void nvnCommandBufferMultiDrawArraysIndirectCount(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode, NVNbufferAddress buffer1, NVNbufferAddress buffer2, int i, ptrdiff_t o)

static void nvnCommandBufferMultiDrawElementsIndirectCount(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode, NVNindexType type, NVNbufferAddress buffer1, NVNbufferAddress buffer2, NVNbufferAddress buffer3, int i, ptrdiff_t o)

static void nvnCommandBufferClearColor(NVNcommandBuffer* cmdBuf, int index, const float* color, int mask)

static void nvnCommandBufferClearColori(NVNcommandBuffer* cmdBuf, int index, const int* color, int mask)

static void nvnCommandBufferClearColorui(NVNcommandBuffer* cmdBuf, int index, const uint32_t* color, int mask)

static void nvnCommandBufferClearDepthStencil(NVNcommandBuffer* cmdBuf, float depthValue, NVNboolean depthMask, int stencilValue, int stencilMask)

static void nvnCommandBufferDispatchCompute(NVNcommandBuffer* cmdBuf, int groupsX, int groupsY, int groupsZ)

static void nvnCommandBufferDispatchComputeIndirect(NVNcommandBuffer* cmdBuf, NVNbufferAddress buffer)

static void nvnCommandBufferSetViewport(NVNcommandBuffer* cmdBuf, int x, int y, int w, int h)

static void nvnCommandBufferSetViewports(NVNcommandBuffer* cmdBuf, int first, int count, const float* ranges)

static void nvnCommandBufferSetViewportSwizzles(NVNcommandBuffer* cmdBuf, int first, int count, const NVNviewportSwizzle* swizzles)

static void nvnCommandBufferSetScissor(NVNcommandBuffer* cmdBuf, int x, int y, int w, int h)

static void nvnCommandBufferSetScissors(NVNcommandBuffer* cmdBuf, int first, int count, const int* rects)

static void nvnCommandBufferSetDepthRange(NVNcommandBuffer* cmdBuf, float n, float f)

static void nvnCommandBufferSetDepthBounds(NVNcommandBuffer* cmdBuf, NVNboolean enable, float n, float f)

static void nvnCommandBufferSetDepthRanges(NVNcommandBuffer* cmdBuf, int first, int count, const float* ranges)

static void nvnCommandBufferSetTiledCacheAction(NVNcommandBuffer* cmdBuf, NVNtiledCacheAction action)

static void nvnCommandBufferSetTiledCacheTileSize(NVNcommandBuffer* cmdBuf, int w, int h)

static void nvnCommandBufferBindSeparateTexture(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int i, NVNseparateTextureHandle handle)

static void nvnCommandBufferBindSeparateSampler(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int i, NVNseparateSamplerHandle handle)

static void nvnCommandBufferBindSeparateTextures(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int i1, int i2, const NVNseparateTextureHandle* handle)

static void nvnCommandBufferBindSeparateSamplers(NVNcommandBuffer* cmdBuf, NVNshaderStage stage, int i1, int i2, const NVNseparateSamplerHandle* handle)

static void nvnCommandBufferSetStencilValueMask(NVNcommandBuffer* cmdBuf, NVNface faces, int mask)

static void nvnCommandBufferSetStencilMask(NVNcommandBuffer* cmdBuf, NVNface faces, int mask)

static void nvnCommandBufferSetStencilRef(NVNcommandBuffer* cmdBuf, NVNface faces, int ref)

static void nvnCommandBufferSetBlendColor(NVNcommandBuffer* cmdBuf, const float* blendColor)

static void nvnCommandBufferSetPointSize(NVNcommandBuffer* cmdBuf, float pointSize)

static void nvnCommandBufferSetLineWidth(NVNcommandBuffer* cmdBuf, float lineWidth)

static void nvnCommandBufferSetPolygonOffsetClamp(NVNcommandBuffer* cmdBuf, float factor, float units, float clamp)

static void nvnCommandBufferSetAlphaRef(NVNcommandBuffer* cmdBuf, float ref)

static void nvnCommandBufferSetSampleMask(NVNcommandBuffer* cmdBuf, int mask)

static void nvnCommandBufferSetRasterizerDiscard(NVNcommandBuffer* cmdBuf, NVNboolean discard)

static void nvnCommandBufferSetDepthClamp(NVNcommandBuffer* cmdBuf, NVNboolean clamp)

static void nvnCommandBufferSetConservativeRasterEnable(NVNcommandBuffer* cmdBuf, NVNboolean enable)

static void nvnCommandBufferSetConservativeRasterDilate(NVNcommandBuffer* cmdBuf, float f)

static void nvnCommandBufferSetSubpixelPrecisionBias(NVNcommandBuffer* cmdBuf, int i1, int i2)

static void nvnCommandBufferCopyBufferToTexture(NVNcommandBuffer* cmdBuf, NVNbufferAddress buffer, const NVNtexture* dstTexture, const NVNtextureView* dstView, const NVNcopyRegion* dstRegion, int flags)

static void nvnCommandBufferCopyTextureToBuffer(NVNcommandBuffer* cmdBuf, const NVNtexture* srcTexture, const NVNtextureView* srcView, const NVNcopyRegion* srcRegion, NVNbufferAddress buffer, int flags)

static void nvnCommandBufferCopyTextureToTexture(NVNcommandBuffer* cmdBuf, const NVNtexture* srcTexture, const NVNtextureView* srcView, const NVNcopyRegion* srcRegion, const NVNtexture* dstTexture, const NVNtextureView* dstView, const NVNcopyRegion* dstRegion, int flags)

static void nvnCommandBufferCopyBufferToBuffer(NVNcommandBuffer* cmdBuf, NVNbufferAddress src, NVNbufferAddress dst, size_t size, int flags)

static void nvnCommandBufferClearBuffer(NVNcommandBuffer* cmdBuf, NVNbufferAddress buffer, size_t size, uint32_t i)

static void nvnCommandBufferClearTexture(NVNcommandBuffer* cmdBuf, const NVNtexture* dstTexture, const NVNtextureView* dstView, const NVNcopyRegion* dstRegion, const float* color, int mask)

static void nvnCommandBufferClearTexturei(NVNcommandBuffer* cmdBuf, const NVNtexture* dstTexture, const NVNtextureView* dstView, const NVNcopyRegion* dstRegion, const int* color, int mask)

static void nvnCommandBufferClearTextureui(NVNcommandBuffer* cmdBuf, const NVNtexture* dstTexture, const NVNtextureView* dstView, const NVNcopyRegion* dstRegion, const uint32_t* color, int mask)

static void nvnCommandBufferUpdateUniformBuffer(NVNcommandBuffer* cmdBuf, NVNbufferAddress buffer, size_t size, ptrdiff_t o, size_t s, const void* p)

static void nvnCommandBufferReportCounter(NVNcommandBuffer* cmdBuf, NVNcounterType counter, NVNbufferAddress buffer)

static void nvnCommandBufferResetCounter(NVNcommandBuffer* cmdBuf, NVNcounterType counter)

static void nvnCommandBufferReportValue(NVNcommandBuffer* cmdBuf, uint32_t value, NVNbufferAddress buffer)

static void nvnCommandBufferSetRenderEnable(NVNcommandBuffer* cmdBuf, NVNboolean enable)

static void nvnCommandBufferSetRenderEnableConditional(NVNcommandBuffer* cmdBuf, NVNconditionalRenderMode mode, NVNbufferAddress addr)

static void nvnCommandBufferSetRenderTargets(NVNcommandBuffer* cmdBuf, int numColors, const NVNtexture*const* colors, const NVNtextureView*const* colorViews, const NVNtexture* depthStencil, const NVNtextureView* depthStencilView)

static void nvnCommandBufferDiscardColor(NVNcommandBuffer* cmdBuf, int i)

static void nvnCommandBufferDiscardDepthStencil(NVNcommandBuffer* cmdBuf)

static void nvnCommandBufferDownsample(NVNcommandBuffer* cmdBuf, const NVNtexture* src, const NVNtexture* dst)

static void nvnCommandBufferTiledDownsample(NVNcommandBuffer* cmdBuf, const NVNtexture* texture1, const NVNtexture* texture2)

static void nvnCommandBufferDownsampleTextureView(NVNcommandBuffer* cmdBuf, const NVNtexture* texture1, const NVNtextureView* view1, const NVNtexture* texture2, const NVNtextureView* view2)

static void nvnCommandBufferTiledDownsampleTextureView(NVNcommandBuffer* cmdBuf, const NVNtexture* texture1, const NVNtextureView* view1, const NVNtexture* texture2, const NVNtextureView* view2)

static void nvnCommandBufferBarrier(NVNcommandBuffer* cmdBuf, int barrier)

static void nvnCommandBufferWaitSync(NVNcommandBuffer* cmdBuf, const NVNsync* sync)

static void nvnCommandBufferFenceSync(NVNcommandBuffer* cmdBuf, NVNsync* sync, NVNsyncCondition condition, int fence)

static void nvnCommandBufferSetTexturePool(NVNcommandBuffer* cmdBuf, const NVNtexturePool* pool)

static void nvnCommandBufferSetSamplerPool(NVNcommandBuffer* cmdBuf, const NVNsamplerPool* pool)

static void nvnCommandBufferSetShaderScratchMemory(NVNcommandBuffer* cmdBuf, const NVNmemoryPool* pool, ptrdiff_t offset, size_t size)

static void nvnCommandBufferSaveZCullData(NVNcommandBuffer* cmdBuf, NVNbufferAddress addr, size_t size)

static void nvnCommandBufferRestoreZCullData(NVNcommandBuffer* cmdBuf, NVNbufferAddress addr, size_t size)

static void nvnCommandBufferSetCopyRowStride(NVNcommandBuffer* cmdBuf, ptrdiff_t stride)

static void nvnCommandBufferSetCopyImageStride(NVNcommandBuffer* cmdBuf, ptrdiff_t stride)

static auto nvnCommandBufferGetCopyRowStride(const NVNcommandBuffer* cmdBuf) -> ptrdiff_t

static auto nvnCommandBufferGetCopyImageStride(const NVNcommandBuffer* cmdBuf) -> ptrdiff_t

static void nvnCommandBufferDrawTexture(NVNcommandBuffer* cmdBuf, NVNtextureHandle handle, const NVNdrawTextureRegion* region1, const NVNdrawTextureRegion* region2)

static auto nvnProgramSetSubroutineLinkage(NVNprogram* program, int i, const NVNsubroutineLinkageMapPtr* ptr) -> NVNboolean

static void nvnCommandBufferSetProgramSubroutines(NVNcommandBuffer* cmdBuf, NVNprogram* program, NVNshaderStage stage, const int i1, const int i2, const int* i3)

static void nvnCommandBufferBindCoverageModulationTable(NVNcommandBuffer* cmdBuf, const float* f)

static void nvnCommandBufferResolveDepthBuffer(NVNcommandBuffer* cmdBuf)

static void nvnCommandBufferPushDebugGroupStatic(NVNcommandBuffer* cmdBuf, uint32_t i, const char* description)

static void nvnCommandBufferPushDebugGroupDynamic(NVNcommandBuffer* cmdBuf, uint32_t i, const char* description)

static void nvnCommandBufferPushDebugGroup(NVNcommandBuffer* cmdBuf, uint32_t i, const char* description)

static void nvnCommandBufferPopDebugGroup(NVNcommandBuffer* cmdBuf)

static void nvnCommandBufferPopDebugGroupId(NVNcommandBuffer* cmdBuf, uint32_t i)

static void nvnCommandBufferInsertDebugMarkerStatic(NVNcommandBuffer* cmdBuf, uint32_t i, const char* description)

static void nvnCommandBufferInsertDebugMarkerDynamic(NVNcommandBuffer* cmdBuf, uint32_t i, const char* description)

static void nvnCommandBufferInsertDebugMarker(NVNcommandBuffer* cmdBuf, const char* description)

static auto nvnCommandBufferGetMemoryCallback(const NVNcommandBuffer* cmdBuf) -> PFNNVNCOMMANDBUFFERMEMORYCALLBACKPROC

static void nvnCommandBufferGetMemoryCallbackData(const NVNcommandBuffer* cmdBuf)

static auto nvnCommandBufferIsRecording(const NVNcommandBuffer* cmdBuf) -> NVNboolean

static auto nvnSyncInitialize(NVNsync* sync, NVNdevice* device) -> NVNboolean

static void nvnSyncFinalize(NVNsync* sync)

static void nvnSyncSetDebugLabel(NVNsync* sync, const char* label)

static void nvnQueueFenceSync(NVNqueue* queue, NVNsync* sync, NVNsyncCondition condition, int flags)

static auto nvnSyncWait(const NVNsync* sync, uint64_t timeoutNs) -> NVNsyncWaitResult

static auto nvnQueueWaitSync(NVNqueue* queue, const NVNsync* sync) -> NVNboolean

static void nvnEventBuilderSetDefaults(NVNeventBuilder* builder)

static void nvnEventBuilderSetStorage(NVNeventBuilder* builder, const NVNmemoryPool* pool, int64_t size)

static auto nvnEventInitialize(NVNevent* event, const NVNeventBuilder* builder) -> NVNboolean

static void nvnEventFinalize(NVNevent* event)

static auto nvnEventGetValue(const NVNevent* event) -> uint32_t

static void nvnEventSignal(NVNevent* event, NVNeventSignalMode mode, uint32_t i)

static void nvnCommandBufferWaitEvent(NVNcommandBuffer* cmdBuf, const NVNevent* event, NVNeventWaitMode mode, uint32_t i)

static void nvnCommandBufferSignalEvent(NVNcommandBuffer* cmdBuf, const NVNevent* event, NVNeventSignalMode mode, NVNeventSignalLocation location, int flags, uint32_t i)