1#pragma once
2
3#include <nvn/nvn_FuncPtrBase.h>
4
5#ifdef __cplusplus
6extern "C" {
7#endif
8
9static inline void nvnDeviceBuilderSetDefaults(NVNdeviceBuilder* builder) {
10 pfnc_nvnDeviceBuilderSetDefaults(builder);
11}
12
13static inline void nvnDeviceBuilderSetFlags(NVNdeviceBuilder* builder, int flags) {
14 pfnc_nvnDeviceBuilderSetFlags(builder, flags);
15}
16
17static inline NVNboolean nvnDeviceInitialize(NVNdevice* device, const NVNdeviceBuilder* builder) {
18 return pfnc_nvnDeviceInitialize(device, builder);
19}
20
21static inline void nvnDeviceFinalize(NVNdevice* device) {
22 pfnc_nvnDeviceFinalize(device);
23}
24
25static inline void nvnDeviceSetDebugLabel(NVNdevice* device, const char* label) {
26 pfnc_nvnDeviceSetDebugLabel(device, label);
27}
28
29static inline PFNNVNGENERICFUNCPTRPROC nvnDeviceGetProcAddress(const NVNdevice* device,
30 const char* s) {
31 return pfnc_nvnDeviceGetProcAddress(device, s);
32}
33
34static inline void nvnDeviceGetInteger(const NVNdevice* device, NVNdeviceInfo pname, int* v) {
35 pfnc_nvnDeviceGetInteger(device, pname, v);
36}
37
38static inline uint64_t nvnDeviceGetCurrentTimestampInNanoseconds(const NVNdevice* device) {
39 return pfnc_nvnDeviceGetCurrentTimestampInNanoseconds(device);
40}
41
42static inline void nvnDeviceSetIntermediateShaderCache(NVNdevice* device, int i) {
43 pfnc_nvnDeviceSetIntermediateShaderCache(device, i);
44}
45
46static inline NVNtextureHandle nvnDeviceGetTextureHandle(const NVNdevice* device, int textureID,
47 int samplerID) {
48 return pfnc_nvnDeviceGetTextureHandle(device, textureID, samplerID);
49}
50
51static inline NVNtextureHandle nvnDeviceGetTexelFetchHandle(const NVNdevice* device,
52 int textureID) {
53 return pfnc_nvnDeviceGetTexelFetchHandle(device, textureID);
54}
55
56static inline NVNimageHandle nvnDeviceGetImageHandle(const NVNdevice* device, int textureID) {
57 return pfnc_nvnDeviceGetImageHandle(device, textureID);
58}
59
60static inline void nvnDeviceInstallDebugCallback(NVNdevice* device,
61 const PFNNVNDEBUGCALLBACKPROC callback,
62 void* callbackData, NVNboolean enable) {
63 pfnc_nvnDeviceInstallDebugCallback(device, callback, callbackData, enable);
64}
65
66static inline NVNdebugDomainId nvnDeviceGenerateDebugDomainId(const NVNdevice* device,
67 const char* s) {
68 return pfnc_nvnDeviceGenerateDebugDomainId(device, s);
69}
70
71static inline void nvnDeviceSetWindowOriginMode(NVNdevice* device,
72 NVNwindowOriginMode windowOriginMode) {
73 pfnc_nvnDeviceSetWindowOriginMode(device, windowOriginMode);
74}
75
76static inline void nvnDeviceSetDepthMode(NVNdevice* device, NVNdepthMode depthMode) {
77 pfnc_nvnDeviceSetDepthMode(device, depthMode);
78}
79
80static inline NVNboolean nvnDeviceRegisterFastClearColor(NVNdevice* device, const float* color,
81 NVNformat format) {
82 return pfnc_nvnDeviceRegisterFastClearColor(device, color, format);
83}
84
85static inline NVNboolean nvnDeviceRegisterFastClearColori(NVNdevice* device, const int* color,
86 NVNformat format) {
87 return pfnc_nvnDeviceRegisterFastClearColori(device, color, format);
88}
89
90static inline NVNboolean nvnDeviceRegisterFastClearColorui(NVNdevice* device, const uint32_t* color,
91 NVNformat format) {
92 return pfnc_nvnDeviceRegisterFastClearColorui(device, color, format);
93}
94
95static inline NVNboolean nvnDeviceRegisterFastClearDepth(NVNdevice* device, float f) {
96 return pfnc_nvnDeviceRegisterFastClearDepth(device, f);
97}
98
99static inline NVNwindowOriginMode nvnDeviceGetWindowOriginMode(const NVNdevice* device) {
100 return pfnc_nvnDeviceGetWindowOriginMode(device);
101}
102
103static inline NVNdepthMode nvnDeviceGetDepthMode(const NVNdevice* device) {
104 return pfnc_nvnDeviceGetDepthMode(device);
105}
106
107static inline uint64_t nvnDeviceGetTimestampInNanoseconds(const NVNdevice* device,
108 const NVNcounterData* counterData) {
109 return pfnc_nvnDeviceGetTimestampInNanoseconds(device, counterData);
110}
111
112static inline void nvnDeviceApplyDeferredFinalizes(NVNdevice* device, int i) {
113 pfnc_nvnDeviceApplyDeferredFinalizes(device, i);
114}
115
116static inline void nvnDeviceFinalizeCommandHandle(NVNdevice* device, NVNcommandHandle handles) {
117 pfnc_nvnDeviceFinalizeCommandHandle(device, handles);
118}
119
120static inline void nvnDeviceWalkDebugDatabase(const NVNdevice* device,
121 NVNdebugObjectType debugObjectType,
122 PFNNVNWALKDEBUGDATABASECALLBACKPROC callback,
123 void* callbackData) {
124 pfnc_nvnDeviceWalkDebugDatabase(device, debugObjectType, callback, callbackData);
125}
126
127static inline NVNseparateTextureHandle nvnDeviceGetSeparateTextureHandle(const NVNdevice* device,
128 int textureID) {
129 return pfnc_nvnDeviceGetSeparateTextureHandle(device, textureID);
130}
131
132static inline NVNseparateSamplerHandle nvnDeviceGetSeparateSamplerHandle(const NVNdevice* device,
133 int textureID) {
134 return pfnc_nvnDeviceGetSeparateSamplerHandle(device, textureID);
135}
136
137static inline NVNboolean nvnDeviceIsExternalDebuggerAttached(const NVNdevice* device) {
138 return pfnc_nvnDeviceIsExternalDebuggerAttached(device);
139}
140
141static inline NVNqueueGetErrorResult nvnQueueGetError(NVNqueue* queue, NVNqueueErrorInfo* info) {
142 return pfnc_nvnQueueGetError(queue, info);
143}
144
145static inline size_t nvnQueueGetTotalCommandMemoryUsed(NVNqueue* queue) {
146 return pfnc_nvnQueueGetTotalCommandMemoryUsed(queue);
147}
148
149static inline size_t nvnQueueGetTotalControlMemoryUsed(NVNqueue* queue) {
150 return pfnc_nvnQueueGetTotalControlMemoryUsed(queue);
151}
152
153static inline size_t nvnQueueGetTotalComputeMemoryUsed(NVNqueue* queue) {
154 return pfnc_nvnQueueGetTotalComputeMemoryUsed(queue);
155}
156
157static inline void nvnQueueResetMemoryUsageCounts(NVNqueue* queue) {
158 pfnc_nvnQueueResetMemoryUsageCounts(queue);
159}
160
161static inline void nvnQueueBuilderSetDevice(NVNqueueBuilder* builder, NVNdevice* device) {
162 pfnc_nvnQueueBuilderSetDevice(builder, device);
163}
164
165static inline void nvnQueueBuilderSetDefaults(NVNqueueBuilder* builder) {
166 pfnc_nvnQueueBuilderSetDefaults(builder);
167}
168
169static inline void nvnQueueBuilderSetFlags(NVNqueueBuilder* builder, int flags) {
170 pfnc_nvnQueueBuilderSetFlags(builder, flags);
171}
172
173static inline void nvnQueueBuilderSetCommandMemorySize(NVNqueueBuilder* builder, size_t size) {
174 pfnc_nvnQueueBuilderSetCommandMemorySize(builder, size);
175}
176
177static inline void nvnQueueBuilderSetComputeMemorySize(NVNqueueBuilder* builder, size_t size) {
178 pfnc_nvnQueueBuilderSetComputeMemorySize(builder, size);
179}
180
181static inline void nvnQueueBuilderSetControlMemorySize(NVNqueueBuilder* builder, size_t size) {
182 pfnc_nvnQueueBuilderSetControlMemorySize(builder, size);
183}
184
185static inline size_t nvnQueueBuilderGetQueueMemorySize(const NVNqueueBuilder* builder) {
186 return pfnc_nvnQueueBuilderGetQueueMemorySize(builder);
187}
188
189static inline void nvnQueueBuilderSetQueueMemory(NVNqueueBuilder* builder, void* memory,
190 size_t size) {
191 pfnc_nvnQueueBuilderSetQueueMemory(builder, memory, size);
192}
193
194static inline void nvnQueueBuilderSetCommandFlushThreshold(NVNqueueBuilder* builder, size_t size) {
195 pfnc_nvnQueueBuilderSetCommandFlushThreshold(builder, size);
196}
197
198static inline NVNboolean nvnQueueInitialize(NVNqueue* queue, const NVNqueueBuilder* builder) {
199 return pfnc_nvnQueueInitialize(queue, builder);
200}
201
202static inline void nvnQueueFinalize(NVNqueue* queue) {
203 pfnc_nvnQueueFinalize(queue);
204}
205
206static inline void nvnQueueSetDebugLabel(NVNqueue* queue, const char* label) {
207 pfnc_nvnQueueSetDebugLabel(queue, label);
208}
209
210static inline void nvnQueueSubmitCommands(NVNqueue* queue, int numCommands,
211 const NVNcommandHandle* handles) {
212 pfnc_nvnQueueSubmitCommands(queue, numCommands, handles);
213}
214
215static inline void nvnQueueFlush(NVNqueue* queue) {
216 pfnc_nvnQueueFlush(queue);
217}
218
219static inline void nvnQueueFinish(NVNqueue* queue) {
220 pfnc_nvnQueueFinish(queue);
221}
222
223static inline void nvnQueuePresentTexture(NVNqueue* queue, NVNwindow* window, int textureIndex) {
224 pfnc_nvnQueuePresentTexture(queue, window, textureIndex);
225}
226
227static inline NVNqueueAcquireTextureResult
228nvnQueueAcquireTexture(NVNqueue* queue, NVNwindow* window, int* textureIndex) {
229 return pfnc_nvnQueueAcquireTexture(queue, window, textureIndex);
230}
231
232static inline void nvnWindowBuilderSetDevice(NVNwindowBuilder* builder, NVNdevice* device) {
233 pfnc_nvnWindowBuilderSetDevice(builder, device);
234}
235
236static inline void nvnWindowBuilderSetDefaults(NVNwindowBuilder* builder) {
237 pfnc_nvnWindowBuilderSetDefaults(builder);
238}
239
240static inline void nvnWindowBuilderSetNativeWindow(NVNwindowBuilder* builder,
241 NVNnativeWindow nativeWindow) {
242 pfnc_nvnWindowBuilderSetNativeWindow(builder, nativeWindow);
243}
244
245static inline void nvnWindowBuilderSetTextures(NVNwindowBuilder* builder, int numTextures,
246 NVNtexture* const* textures) {
247 pfnc_nvnWindowBuilderSetTextures(builder, numTextures, textures);
248}
249
250static inline void nvnWindowBuilderSetPresentInterval(NVNwindowBuilder* builder,
251 int presentInterval) {
252 pfnc_nvnWindowBuilderSetPresentInterval(builder, presentInterval);
253}
254
255static inline NVNnativeWindow nvnWindowBuilderGetNativeWindow(const NVNwindowBuilder* builder) {
256 return pfnc_nvnWindowBuilderGetNativeWindow(builder);
257}
258
259static inline int nvnWindowBuilderGetPresentInterval(const NVNwindowBuilder* builder) {
260 return pfnc_nvnWindowBuilderGetPresentInterval(builder);
261}
262
263static inline NVNboolean nvnWindowInitialize(NVNwindow* window, const NVNwindowBuilder* builder) {
264 return pfnc_nvnWindowInitialize(window, builder);
265}
266
267static inline void nvnWindowFinalize(NVNwindow* window) {
268 pfnc_nvnWindowFinalize(window);
269}
270
271static inline void nvnWindowSetDebugLabel(NVNwindow* window, const char* label) {
272 pfnc_nvnWindowSetDebugLabel(window, label);
273}
274
275static inline NVNwindowAcquireTextureResult
276nvnWindowAcquireTexture(NVNwindow* window, NVNsync* textureAvailableSync, int* textureIndex) {
277 return pfnc_nvnWindowAcquireTexture(window, textureAvailableSync, textureIndex);
278}
279
280static inline NVNnativeWindow nvnWindowGetNativeWindow(const NVNwindow* window) {
281 return pfnc_nvnWindowGetNativeWindow(window);
282}
283
284static inline int nvnWindowGetPresentInterval(const NVNwindow* window) {
285 return pfnc_nvnWindowGetPresentInterval(window);
286}
287
288static inline void nvnWindowSetPresentInterval(NVNwindow* window, int presentInterval) {
289 pfnc_nvnWindowSetPresentInterval(window, presentInterval);
290}
291
292static inline void nvnWindowSetCrop(NVNwindow* window, int x, int y, int w, int h) {
293 pfnc_nvnWindowSetCrop(window, x, y, w, h);
294}
295
296static inline void nvnWindowGetCrop(const NVNwindow* window, NVNrectangle* rectangle) {
297 pfnc_nvnWindowGetCrop(window, rectangle);
298}
299
300static inline NVNboolean nvnProgramInitialize(NVNprogram* program, NVNdevice* device) {
301 return pfnc_nvnProgramInitialize(program, device);
302}
303
304static inline void nvnProgramFinalize(NVNprogram* program) {
305 pfnc_nvnProgramFinalize(program);
306}
307
308static inline void nvnProgramSetDebugLabel(NVNprogram* program, const char* label) {
309 pfnc_nvnProgramSetDebugLabel(program, label);
310}
311
312static inline NVNboolean nvnProgramSetShaders(NVNprogram* program, int count,
313 const NVNshaderData* stageData) {
314 return pfnc_nvnProgramSetShaders(program, count, stageData);
315}
316
317static inline void nvnMemoryPoolBuilderSetDevice(NVNmemoryPoolBuilder* builder, NVNdevice* device) {
318 pfnc_nvnMemoryPoolBuilderSetDevice(builder, device);
319}
320
321static inline void nvnMemoryPoolBuilderSetDefaults(NVNmemoryPoolBuilder* builder) {
322 pfnc_nvnMemoryPoolBuilderSetDefaults(builder);
323}
324
325static inline void nvnMemoryPoolBuilderSetStorage(NVNmemoryPoolBuilder* builder, void* memory,
326 size_t size) {
327 pfnc_nvnMemoryPoolBuilderSetStorage(builder, memory, size);
328}
329
330static inline void nvnMemoryPoolBuilderSetFlags(NVNmemoryPoolBuilder* builder, int flags) {
331 pfnc_nvnMemoryPoolBuilderSetFlags(builder, flags);
332}
333
334static inline void nvnMemoryPoolBuilderGetMemory(const NVNmemoryPoolBuilder* builder) {
335 pfnc_nvnMemoryPoolBuilderGetMemory(builder);
336}
337
338static inline size_t nvnMemoryPoolBuilderGetSize(const NVNmemoryPoolBuilder* builder) {
339 return pfnc_nvnMemoryPoolBuilderGetSize(builder);
340}
341
342static inline NVNmemoryPoolFlags nvnMemoryPoolBuilderGetFlags(const NVNmemoryPoolBuilder* builder) {
343 return pfnc_nvnMemoryPoolBuilderGetFlags(builder);
344}
345
346static inline NVNboolean nvnMemoryPoolInitialize(NVNmemoryPool* pool,
347 const NVNmemoryPoolBuilder* builder) {
348 return pfnc_nvnMemoryPoolInitialize(pool, builder);
349}
350
351static inline void nvnMemoryPoolSetDebugLabel(NVNmemoryPool* pool, const char* label) {
352 pfnc_nvnMemoryPoolSetDebugLabel(pool, label);
353}
354
355static inline void nvnMemoryPoolFinalize(NVNmemoryPool* pool) {
356 pfnc_nvnMemoryPoolFinalize(pool);
357}
358
359static inline void* nvnMemoryPoolMap(const NVNmemoryPool* pool) {
360 return pfnc_nvnMemoryPoolMap(pool);
361}
362
363static inline void nvnMemoryPoolFlushMappedRange(const NVNmemoryPool* pool, ptrdiff_t offset,
364 size_t size) {
365 pfnc_nvnMemoryPoolFlushMappedRange(pool, offset, size);
366}
367
368static inline void nvnMemoryPoolInvalidateMappedRange(const NVNmemoryPool* pool, ptrdiff_t offset,
369 size_t size) {
370 pfnc_nvnMemoryPoolInvalidateMappedRange(pool, offset, size);
371}
372
373static inline NVNbufferAddress nvnMemoryPoolGetBufferAddress(const NVNmemoryPool* pool) {
374 return pfnc_nvnMemoryPoolGetBufferAddress(pool);
375}
376
377static inline NVNboolean nvnMemoryPoolMapVirtual(NVNmemoryPool* pool, int numRequests,
378 const NVNmappingRequest* requests) {
379 return pfnc_nvnMemoryPoolMapVirtual(pool, numRequests, requests);
380}
381
382static inline size_t nvnMemoryPoolGetSize(const NVNmemoryPool* pool) {
383 return pfnc_nvnMemoryPoolGetSize(pool);
384}
385
386static inline NVNmemoryPoolFlags nvnMemoryPoolGetFlags(const NVNmemoryPool* pool) {
387 return pfnc_nvnMemoryPoolGetFlags(pool);
388}
389
390static inline NVNboolean nvnTexturePoolInitialize(NVNtexturePool* texturePool,
391 const NVNmemoryPool* memoryPool, ptrdiff_t offset,
392 int numDescriptors) {
393 return pfnc_nvnTexturePoolInitialize(texturePool, memoryPool, offset, numDescriptors);
394}
395
396static inline void nvnTexturePoolSetDebugLabel(NVNtexturePool* pool, const char* label) {
397 pfnc_nvnTexturePoolSetDebugLabel(pool, label);
398}
399
400static inline void nvnTexturePoolFinalize(NVNtexturePool* pool) {
401 pfnc_nvnTexturePoolFinalize(pool);
402}
403
404static inline void nvnTexturePoolRegisterTexture(const NVNtexturePool* pool, int id,
405 const NVNtexture* texture,
406 const NVNtextureView* view) {
407 pfnc_nvnTexturePoolRegisterTexture(pool, id, texture, view);
408}
409
410static inline void nvnTexturePoolRegisterImage(const NVNtexturePool* pool, int id,
411 const NVNtexture* texture,
412 const NVNtextureView* view) {
413 pfnc_nvnTexturePoolRegisterImage(pool, id, texture, view);
414}
415
416static inline const NVNmemoryPool* nvnTexturePoolGetMemoryPool(const NVNtexturePool* pool) {
417 return pfnc_nvnTexturePoolGetMemoryPool(pool);
418}
419
420static inline ptrdiff_t nvnTexturePoolGetMemoryOffset(const NVNtexturePool* pool) {
421 return pfnc_nvnTexturePoolGetMemoryOffset(pool);
422}
423
424static inline int nvnTexturePoolGetSize(const NVNtexturePool* pool) {
425 return pfnc_nvnTexturePoolGetSize(pool);
426}
427
428static inline NVNboolean nvnSamplerPoolInitialize(NVNsamplerPool* samplerPool,
429 const NVNmemoryPool* memoryPool, ptrdiff_t offset,
430 int numDescriptors) {
431 return pfnc_nvnSamplerPoolInitialize(samplerPool, memoryPool, offset, numDescriptors);
432}
433
434static inline void nvnSamplerPoolSetDebugLabel(NVNsamplerPool* pool, const char* label) {
435 pfnc_nvnSamplerPoolSetDebugLabel(pool, label);
436}
437
438static inline void nvnSamplerPoolFinalize(NVNsamplerPool* pool) {
439 pfnc_nvnSamplerPoolFinalize(pool);
440}
441
442static inline void nvnSamplerPoolRegisterSampler(const NVNsamplerPool* pool, int id,
443 const NVNsampler* sampler) {
444 pfnc_nvnSamplerPoolRegisterSampler(pool, id, sampler);
445}
446
447static inline void nvnSamplerPoolRegisterSamplerBuilder(const NVNsamplerPool* pool, int id,
448 const NVNsamplerBuilder* builder) {
449 pfnc_nvnSamplerPoolRegisterSamplerBuilder(pool, id, builder);
450}
451
452static inline const NVNmemoryPool* nvnSamplerPoolGetMemoryPool(const NVNsamplerPool* pool) {
453 return pfnc_nvnSamplerPoolGetMemoryPool(pool);
454}
455
456static inline ptrdiff_t nvnSamplerPoolGetMemoryOffset(const NVNsamplerPool* pool) {
457 return pfnc_nvnSamplerPoolGetMemoryOffset(pool);
458}
459
460static inline int nvnSamplerPoolGetSize(const NVNsamplerPool* pool) {
461 return pfnc_nvnSamplerPoolGetSize(pool);
462}
463
464static inline void nvnBufferBuilderSetDevice(NVNbufferBuilder* builder, NVNdevice* device) {
465 pfnc_nvnBufferBuilderSetDevice(builder, device);
466}
467
468static inline void nvnBufferBuilderSetDefaults(NVNbufferBuilder* builder) {
469 pfnc_nvnBufferBuilderSetDefaults(builder);
470}
471
472static inline void nvnBufferBuilderSetStorage(NVNbufferBuilder* builder, NVNmemoryPool* pool,
473 ptrdiff_t offset, size_t size) {
474 pfnc_nvnBufferBuilderSetStorage(builder, pool, offset, size);
475}
476
477static inline NVNmemoryPool nvnBufferBuilderGetMemoryPool(const NVNbufferBuilder* builder) {
478 return pfnc_nvnBufferBuilderGetMemoryPool(builder);
479}
480
481static inline ptrdiff_t nvnBufferBuilderGetMemoryOffset(const NVNbufferBuilder* builder) {
482 return pfnc_nvnBufferBuilderGetMemoryOffset(builder);
483}
484
485static inline size_t nvnBufferBuilderGetSize(const NVNbufferBuilder* builder) {
486 return pfnc_nvnBufferBuilderGetSize(builder);
487}
488
489static inline NVNboolean nvnBufferInitialize(NVNbuffer* buffer, const NVNbufferBuilder* builder) {
490 return pfnc_nvnBufferInitialize(buffer, builder);
491}
492
493static inline void nvnBufferSetDebugLabel(NVNbuffer* buffer, const char* label) {
494 pfnc_nvnBufferSetDebugLabel(buffer, label);
495}
496
497static inline void nvnBufferFinalize(NVNbuffer* buffer) {
498 pfnc_nvnBufferFinalize(buffer);
499}
500
501static inline void* nvnBufferMap(const NVNbuffer* buffer) {
502 return pfnc_nvnBufferMap(buffer);
503}
504
505static inline NVNbufferAddress nvnBufferGetAddress(const NVNbuffer* buffer) {
506 return pfnc_nvnBufferGetAddress(buffer);
507}
508
509static inline void nvnBufferFlushMappedRange(const NVNbuffer* buffer, ptrdiff_t offset,
510 size_t size) {
511 pfnc_nvnBufferFlushMappedRange(buffer, offset, size);
512}
513
514static inline void nvnBufferInvalidateMappedRange(const NVNbuffer* buffer, ptrdiff_t offset,
515 size_t size) {
516 pfnc_nvnBufferInvalidateMappedRange(buffer, offset, size);
517}
518
519static inline NVNmemoryPool* nvnBufferGetMemoryPool(const NVNbuffer* buffer) {
520 return pfnc_nvnBufferGetMemoryPool(buffer);
521}
522
523static inline ptrdiff_t nvnBufferGetMemoryOffset(const NVNbuffer* buffer) {
524 return pfnc_nvnBufferGetMemoryOffset(buffer);
525}
526
527static inline size_t nvnBufferGetSize(const NVNbuffer* buffer) {
528 return pfnc_nvnBufferGetSize(buffer);
529}
530
531static inline uint64_t nvnBufferGetDebugID(const NVNbuffer* buffer) {
532 return pfnc_nvnBufferGetDebugID(buffer);
533}
534
535static inline void nvnTextureBuilderSetDevice(NVNtextureBuilder* builder, NVNdevice* device) {
536 pfnc_nvnTextureBuilderSetDevice(builder, device);
537}
538
539static inline void nvnTextureBuilderSetDefaults(NVNtextureBuilder* builder) {
540 pfnc_nvnTextureBuilderSetDefaults(builder);
541}
542
543static inline void nvnTextureBuilderSetFlags(NVNtextureBuilder* builder, int flags) {
544 pfnc_nvnTextureBuilderSetFlags(builder, flags);
545}
546
547static inline void nvnTextureBuilderSetTarget(NVNtextureBuilder* builder, NVNtextureTarget target) {
548 pfnc_nvnTextureBuilderSetTarget(builder, target);
549}
550
551static inline void nvnTextureBuilderSetWidth(NVNtextureBuilder* builder, int width) {
552 pfnc_nvnTextureBuilderSetWidth(builder, width);
553}
554
555static inline void nvnTextureBuilderSetHeight(NVNtextureBuilder* builder, int height) {
556 pfnc_nvnTextureBuilderSetHeight(builder, height);
557}
558
559static inline void nvnTextureBuilderSetDepth(NVNtextureBuilder* builder, int depth) {
560 pfnc_nvnTextureBuilderSetDepth(builder, depth);
561}
562
563static inline void nvnTextureBuilderSetSize1D(NVNtextureBuilder* builder, int size) {
564 pfnc_nvnTextureBuilderSetSize1D(builder, size);
565}
566
567static inline void nvnTextureBuilderSetSize2D(NVNtextureBuilder* builder, int width, int height) {
568 pfnc_nvnTextureBuilderSetSize2D(builder, width, height);
569}
570
571static inline void nvnTextureBuilderSetSize3D(NVNtextureBuilder* builder, int width, int height,
572 int depth) {
573 pfnc_nvnTextureBuilderSetSize3D(builder, width, height, depth);
574}
575
576static inline void nvnTextureBuilderSetLevels(NVNtextureBuilder* builder, int numLevels) {
577 pfnc_nvnTextureBuilderSetLevels(builder, numLevels);
578}
579
580static inline void nvnTextureBuilderSetFormat(NVNtextureBuilder* builder, NVNformat format) {
581 pfnc_nvnTextureBuilderSetFormat(builder, format);
582}
583
584static inline void nvnTextureBuilderSetSamples(NVNtextureBuilder* builder, int samples) {
585 pfnc_nvnTextureBuilderSetSamples(builder, samples);
586}
587
588static inline void nvnTextureBuilderSetSwizzle(NVNtextureBuilder* builder, NVNtextureSwizzle r,
589 NVNtextureSwizzle g, NVNtextureSwizzle b,
590 NVNtextureSwizzle a) {
591 pfnc_nvnTextureBuilderSetSwizzle(builder, r, g, b, a);
592}
593
594static inline void nvnTextureBuilderSetDepthStencilMode(NVNtextureBuilder* builder,
595 NVNtextureDepthStencilMode mode) {
596 pfnc_nvnTextureBuilderSetDepthStencilMode(builder, mode);
597}
598
599static inline size_t nvnTextureBuilderGetStorageSize(const NVNtextureBuilder* builder) {
600 return pfnc_nvnTextureBuilderGetStorageSize(builder);
601}
602
603static inline size_t nvnTextureBuilderGetStorageAlignment(const NVNtextureBuilder* builder) {
604 return pfnc_nvnTextureBuilderGetStorageAlignment(builder);
605}
606
607static inline void nvnTextureBuilderSetStorage(NVNtextureBuilder* builder, NVNmemoryPool* pool,
608 ptrdiff_t offset) {
609 pfnc_nvnTextureBuilderSetStorage(builder, pool, offset);
610}
611
612static inline void nvnTextureBuilderSetPackagedTextureData(NVNtextureBuilder* builder,
613 const void* data) {
614 pfnc_nvnTextureBuilderSetPackagedTextureData(builder, data);
615}
616
617static inline void
618nvnTextureBuilderSetPackagedTextureLayout(NVNtextureBuilder* builder,
619 const NVNpackagedTextureLayout* layout) {
620 pfnc_nvnTextureBuilderSetPackagedTextureLayout(builder, layout);
621}
622
623static inline void nvnTextureBuilderSetStride(NVNtextureBuilder* builder, ptrdiff_t stride) {
624 pfnc_nvnTextureBuilderSetStride(builder, stride);
625}
626
627static inline void nvnTextureBuilderSetGLTextureName(NVNtextureBuilder* builder, uint32_t name) {
628 pfnc_nvnTextureBuilderSetGLTextureName(builder, name);
629}
630
631static inline NVNstorageClass nvnTextureBuilderGetStorageClass(const NVNtextureBuilder* builder) {
632 return pfnc_nvnTextureBuilderGetStorageClass(builder);
633}
634
635static inline NVNtextureFlags nvnTextureBuilderGetFlags(const NVNtextureBuilder* builder) {
636 return pfnc_nvnTextureBuilderGetFlags(builder);
637}
638
639static inline NVNtextureTarget nvnTextureBuilderGetTarget(const NVNtextureBuilder* builder) {
640 return pfnc_nvnTextureBuilderGetTarget(builder);
641}
642
643static inline int nvnTextureBuilderGetWidth(const NVNtextureBuilder* builder) {
644 return pfnc_nvnTextureBuilderGetWidth(builder);
645}
646
647static inline int nvnTextureBuilderGetHeight(const NVNtextureBuilder* builder) {
648 return pfnc_nvnTextureBuilderGetHeight(builder);
649}
650
651static inline int nvnTextureBuilderGetDepth(const NVNtextureBuilder* builder) {
652 return pfnc_nvnTextureBuilderGetDepth(builder);
653}
654
655static inline int nvnTextureBuilderGetLevels(const NVNtextureBuilder* builder) {
656 return pfnc_nvnTextureBuilderGetLevels(builder);
657}
658
659static inline NVNformat nvnTextureBuilderGetFormat(const NVNtextureBuilder* builder) {
660 return pfnc_nvnTextureBuilderGetFormat(builder);
661}
662
663static inline int nvnTextureBuilderGetSamples(const NVNtextureBuilder* builder) {
664 return pfnc_nvnTextureBuilderGetSamples(builder);
665}
666
667static inline void nvnTextureBuilderGetSwizzle(const NVNtextureBuilder* builder,
668 NVNtextureSwizzle* r, NVNtextureSwizzle* g,
669 NVNtextureSwizzle* b, NVNtextureSwizzle* a) {
670 pfnc_nvnTextureBuilderGetSwizzle(builder, r, g, b, a);
671}
672
673static inline NVNtextureDepthStencilMode
674nvnTextureBuilderGetDepthStencilMode(const NVNtextureBuilder* builder) {
675 return pfnc_nvnTextureBuilderGetDepthStencilMode(builder);
676}
677
678static inline const void*
679nvnTextureBuilderGetPackagedTextureData(const NVNtextureBuilder* builder) {
680 return pfnc_nvnTextureBuilderGetPackagedTextureData(builder);
681}
682
683static inline ptrdiff_t nvnTextureBuilderGetStride(const NVNtextureBuilder* builder) {
684 return pfnc_nvnTextureBuilderGetStride(builder);
685}
686
687static inline void nvnTextureBuilderGetSparseTileLayout(const NVNtextureBuilder* builder,
688 NVNtextureSparseTileLayout* layout) {
689 pfnc_nvnTextureBuilderGetSparseTileLayout(builder, layout);
690}
691
692static inline uint32_t nvnTextureBuilderGetGLTextureName(const NVNtextureBuilder* builder) {
693 return pfnc_nvnTextureBuilderGetGLTextureName(builder);
694}
695
696static inline size_t nvnTextureBuilderGetZCullStorageSize(const NVNtextureBuilder* builder) {
697 return pfnc_nvnTextureBuilderGetZCullStorageSize(builder);
698}
699
700static inline NVNmemoryPool nvnTextureBuilderGetMemoryPool(const NVNtextureBuilder* builder) {
701 return pfnc_nvnTextureBuilderGetMemoryPool(builder);
702}
703
704static inline ptrdiff_t nvnTextureBuilderGetMemoryOffset(const NVNtextureBuilder* builder) {
705 return pfnc_nvnTextureBuilderGetMemoryOffset(builder);
706}
707
708static inline void nvnTextureViewSetDefaults(NVNtextureView* view) {
709 pfnc_nvnTextureViewSetDefaults(view);
710}
711
712static inline void nvnTextureViewSetLevels(NVNtextureView* view, int baseLevel, int numLevels) {
713 pfnc_nvnTextureViewSetLevels(view, baseLevel, numLevels);
714}
715
716static inline void nvnTextureViewSetLayers(NVNtextureView* view, int minLayer, int numLayers) {
717 pfnc_nvnTextureViewSetLayers(view, minLayer, numLayers);
718}
719
720static inline void nvnTextureViewSetFormat(NVNtextureView* view, NVNformat format) {
721 pfnc_nvnTextureViewSetFormat(view, format);
722}
723
724static inline void nvnTextureViewSetSwizzle(NVNtextureView* view, NVNtextureSwizzle r,
725 NVNtextureSwizzle g, NVNtextureSwizzle b,
726 NVNtextureSwizzle a) {
727 pfnc_nvnTextureViewSetSwizzle(view, r, g, b, a);
728}
729
730static inline void nvnTextureViewSetDepthStencilMode(NVNtextureView* view,
731 NVNtextureDepthStencilMode mode) {
732 pfnc_nvnTextureViewSetDepthStencilMode(view, mode);
733}
734
735static inline void nvnTextureViewSetTarget(NVNtextureView* view, NVNtextureTarget target) {
736 pfnc_nvnTextureViewSetTarget(view, target);
737}
738
739static inline NVNboolean nvnTextureViewGetLevels(const NVNtextureView* view, int* baseLevel,
740 int* numLevels) {
741 return pfnc_nvnTextureViewGetLevels(view, baseLevel, numLevels);
742}
743
744static inline NVNboolean nvnTextureViewGetLayers(const NVNtextureView* view, int* minLayer,
745 int* numLayers) {
746 return pfnc_nvnTextureViewGetLayers(view, minLayer, numLayers);
747}
748
749static inline NVNboolean nvnTextureViewGetFormat(const NVNtextureView* view, NVNformat* format) {
750 return pfnc_nvnTextureViewGetFormat(view, format);
751}
752
753static inline NVNboolean nvnTextureViewGetSwizzle(const NVNtextureView* view, NVNtextureSwizzle* r,
754 NVNtextureSwizzle* g, NVNtextureSwizzle* b,
755 NVNtextureSwizzle* a) {
756 return pfnc_nvnTextureViewGetSwizzle(view, r, g, b, a);
757}
758
759static inline NVNboolean nvnTextureViewGetDepthStencilMode(const NVNtextureView* view,
760 NVNtextureDepthStencilMode* mode) {
761 return pfnc_nvnTextureViewGetDepthStencilMode(view, mode);
762}
763
764static inline NVNboolean nvnTextureViewGetTarget(const NVNtextureView* view,
765 NVNtextureTarget* target) {
766 return pfnc_nvnTextureViewGetTarget(view, target);
767}
768
769static inline NVNboolean nvnTextureViewCompare(const NVNtextureView* view1,
770 const NVNtextureView* view2) {
771 return pfnc_nvnTextureViewCompare(view1, view2);
772}
773
774static inline NVNboolean nvnTextureInitialize(NVNtexture* texture,
775 const NVNtextureBuilder* builder) {
776 return pfnc_nvnTextureInitialize(texture, builder);
777}
778
779static inline size_t nvnTextureGetZCullStorageSize(const NVNtexture* texture) {
780 return pfnc_nvnTextureGetZCullStorageSize(texture);
781}
782
783static inline void nvnTextureFinalize(NVNtexture* texture) {
784 pfnc_nvnTextureFinalize(texture);
785}
786
787static inline void nvnTextureSetDebugLabel(NVNtexture* texture, const char* label) {
788 pfnc_nvnTextureSetDebugLabel(texture, label);
789}
790
791static inline NVNstorageClass nvnTextureGetStorageClass(const NVNtexture* texture) {
792 return pfnc_nvnTextureGetStorageClass(texture);
793}
794
795static inline ptrdiff_t nvnTextureGetViewOffset(const NVNtexture* texture,
796 const NVNtextureView* view) {
797 return pfnc_nvnTextureGetViewOffset(texture, view);
798}
799
800static inline NVNtextureFlags nvnTextureGetFlags(const NVNtexture* texture) {
801 return pfnc_nvnTextureGetFlags(texture);
802}
803
804static inline NVNtextureTarget nvnTextureGetTarget(const NVNtexture* texture) {
805 return pfnc_nvnTextureGetTarget(texture);
806}
807
808static inline int nvnTextureGetWidth(const NVNtexture* texture) {
809 return pfnc_nvnTextureGetWidth(texture);
810}
811
812static inline int nvnTextureGetHeight(const NVNtexture* texture) {
813 return pfnc_nvnTextureGetHeight(texture);
814}
815
816static inline int nvnTextureGetDepth(const NVNtexture* texture) {
817 return pfnc_nvnTextureGetDepth(texture);
818}
819
820static inline int nvnTextureGetLevels(const NVNtexture* texture) {
821 return pfnc_nvnTextureGetLevels(texture);
822}
823
824static inline NVNformat nvnTextureGetFormat(const NVNtexture* texture) {
825 return pfnc_nvnTextureGetFormat(texture);
826}
827
828static inline int nvnTextureGetSamples(const NVNtexture* texture) {
829 return pfnc_nvnTextureGetSamples(texture);
830}
831
832static inline void nvnTextureGetSwizzle(const NVNtexture* texture, NVNtextureSwizzle* r,
833 NVNtextureSwizzle* g, NVNtextureSwizzle* b,
834 NVNtextureSwizzle* a) {
835 pfnc_nvnTextureGetSwizzle(texture, r, g, b, a);
836}
837
838static inline NVNtextureDepthStencilMode nvnTextureGetDepthStencilMode(const NVNtexture* texture) {
839 return pfnc_nvnTextureGetDepthStencilMode(texture);
840}
841
842static inline ptrdiff_t nvnTextureGetStride(const NVNtexture* texture) {
843 return pfnc_nvnTextureGetStride(texture);
844}
845
846static inline NVNtextureAddress nvnTextureGetTextureAddress(const NVNtexture* texture) {
847 return pfnc_nvnTextureGetTextureAddress(texture);
848}
849
850static inline void nvnTextureGetSparseTileLayout(const NVNtexture* texture,
851 NVNtextureSparseTileLayout* layout) {
852 pfnc_nvnTextureGetSparseTileLayout(texture, layout);
853}
854
855static inline void nvnTextureWriteTexels(const NVNtexture* texture, const NVNtextureView* view,
856 const NVNcopyRegion* region, const void* p) {
857 pfnc_nvnTextureWriteTexels(texture, view, region, p);
858}
859
860static inline void nvnTextureWriteTexelsStrided(const NVNtexture* texture,
861 const NVNtextureView* view,
862 const NVNcopyRegion* region, const void* p,
863 ptrdiff_t o1, ptrdiff_t o2) {
864 pfnc_nvnTextureWriteTexelsStrided(texture, view, region, p, o1, o2);
865}
866
867static inline void nvnTextureReadTexels(const NVNtexture* texture, const NVNtextureView* view,
868 const NVNcopyRegion* region, void* p) {
869 pfnc_nvnTextureReadTexels(texture, view, region, p);
870}
871
872static inline void nvnTextureReadTexelsStrided(const NVNtexture* texture,
873 const NVNtextureView* view,
874 const NVNcopyRegion* region, void* p, ptrdiff_t o1,
875 ptrdiff_t o2) {
876 pfnc_nvnTextureReadTexelsStrided(texture, view, region, p, o1, o2);
877}
878
879static inline void nvnTextureFlushTexels(const NVNtexture* texture, const NVNtextureView* view,
880 const NVNcopyRegion* region) {
881 pfnc_nvnTextureFlushTexels(texture, view, region);
882}
883
884static inline void nvnTextureInvalidateTexels(const NVNtexture* texture, const NVNtextureView* view,
885 const NVNcopyRegion* region) {
886 pfnc_nvnTextureInvalidateTexels(texture, view, region);
887}
888
889static inline NVNmemoryPool nvnTextureGetMemoryPool(const NVNtexture* texture) {
890 return pfnc_nvnTextureGetMemoryPool(texture);
891}
892
893static inline ptrdiff_t nvnTextureGetMemoryOffset(const NVNtexture* texture) {
894 return pfnc_nvnTextureGetMemoryOffset(texture);
895}
896
897static inline int nvnTextureGetStorageSize(const NVNtexture* texture) {
898 return pfnc_nvnTextureGetStorageSize(texture);
899}
900
901static inline NVNboolean nvnTextureCompare(const NVNtexture* texture1, const NVNtexture* texture2) {
902 return pfnc_nvnTextureCompare(texture1, texture2);
903}
904
905static inline uint64_t nvnTextureGetDebugID(const NVNtexture* texture) {
906 return pfnc_nvnTextureGetDebugID(texture);
907}
908
909static inline void nvnSamplerBuilderSetDevice(NVNsamplerBuilder* builder, NVNdevice* device) {
910 pfnc_nvnSamplerBuilderSetDevice(builder, device);
911}
912
913static inline void nvnSamplerBuilderSetDefaults(NVNsamplerBuilder* builder) {
914 pfnc_nvnSamplerBuilderSetDefaults(builder);
915}
916
917static inline void nvnSamplerBuilderSetMinMagFilter(NVNsamplerBuilder* builder, NVNminFilter min,
918 NVNmagFilter mag) {
919 pfnc_nvnSamplerBuilderSetMinMagFilter(builder, min, mag);
920}
921
922static inline void nvnSamplerBuilderSetWrapMode(NVNsamplerBuilder* builder, NVNwrapMode s,
923 NVNwrapMode t, NVNwrapMode r) {
924 pfnc_nvnSamplerBuilderSetWrapMode(builder, s, t, r);
925}
926
927static inline void nvnSamplerBuilderSetLodClamp(NVNsamplerBuilder* builder, float min, float max) {
928 pfnc_nvnSamplerBuilderSetLodClamp(builder, min, max);
929}
930
931static inline void nvnSamplerBuilderSetLodBias(NVNsamplerBuilder* builder, float bias) {
932 pfnc_nvnSamplerBuilderSetLodBias(builder, bias);
933}
934
935static inline void nvnSamplerBuilderSetCompare(NVNsamplerBuilder* builder, NVNcompareMode mode,
936 NVNcompareFunc func) {
937 pfnc_nvnSamplerBuilderSetCompare(builder, mode, func);
938}
939
940static inline void nvnSamplerBuilderSetBorderColor(NVNsamplerBuilder* builder,
941 const float* borderColor) {
942 pfnc_nvnSamplerBuilderSetBorderColor(builder, borderColor);
943}
944
945static inline void nvnSamplerBuilderSetBorderColori(NVNsamplerBuilder* builder,
946 const int* borderColor) {
947 pfnc_nvnSamplerBuilderSetBorderColori(builder, borderColor);
948}
949
950static inline void nvnSamplerBuilderSetBorderColorui(NVNsamplerBuilder* builder,
951 const uint32_t* borderColor) {
952 pfnc_nvnSamplerBuilderSetBorderColorui(builder, borderColor);
953}
954
955static inline void nvnSamplerBuilderSetMaxAnisotropy(NVNsamplerBuilder* builder, float maxAniso) {
956 pfnc_nvnSamplerBuilderSetMaxAnisotropy(builder, maxAniso);
957}
958
959static inline void nvnSamplerBuilderSetReductionFilter(NVNsamplerBuilder* builder,
960 NVNsamplerReduction filter) {
961 pfnc_nvnSamplerBuilderSetReductionFilter(builder, filter);
962}
963
964static inline void nvnSamplerBuilderSetLodSnap(NVNsamplerBuilder* builder, float f) {
965 pfnc_nvnSamplerBuilderSetLodSnap(builder, f);
966}
967
968static inline void nvnSamplerBuilderGetMinMagFilter(const NVNsamplerBuilder* builder,
969 NVNminFilter* min, NVNmagFilter* mag) {
970 pfnc_nvnSamplerBuilderGetMinMagFilter(builder, min, mag);
971}
972
973static inline void nvnSamplerBuilderGetWrapMode(const NVNsamplerBuilder* builder, NVNwrapMode* s,
974 NVNwrapMode* t, NVNwrapMode* r) {
975 pfnc_nvnSamplerBuilderGetWrapMode(builder, s, t, r);
976}
977
978static inline void nvnSamplerBuilderGetLodClamp(const NVNsamplerBuilder* builder, float* min,
979 float* max) {
980 pfnc_nvnSamplerBuilderGetLodClamp(builder, min, max);
981}
982
983static inline float nvnSamplerBuilderGetLodBias(const NVNsamplerBuilder* builder) {
984 return pfnc_nvnSamplerBuilderGetLodBias(builder);
985}
986
987static inline void nvnSamplerBuilderGetCompare(const NVNsamplerBuilder* builder,
988 NVNcompareMode* mode, NVNcompareFunc* func) {
989 pfnc_nvnSamplerBuilderGetCompare(builder, mode, func);
990}
991
992static inline void nvnSamplerBuilderGetBorderColor(const NVNsamplerBuilder* builder,
993 float* borderColor) {
994 pfnc_nvnSamplerBuilderGetBorderColor(builder, borderColor);
995}
996
997static inline void nvnSamplerBuilderGetBorderColori(const NVNsamplerBuilder* builder,
998 int* borderColor) {
999 pfnc_nvnSamplerBuilderGetBorderColori(builder, borderColor);
1000}
1001
1002static inline void nvnSamplerBuilderGetBorderColorui(const NVNsamplerBuilder* builder,
1003 uint32_t* borderColor) {
1004 pfnc_nvnSamplerBuilderGetBorderColorui(builder, borderColor);
1005}
1006
1007static inline float nvnSamplerBuilderGetMaxAnisotropy(const NVNsamplerBuilder* builder) {
1008 return pfnc_nvnSamplerBuilderGetMaxAnisotropy(builder);
1009}
1010
1011static inline NVNsamplerReduction
1012nvnSamplerBuilderGetReductionFilter(const NVNsamplerBuilder* builder) {
1013 return pfnc_nvnSamplerBuilderGetReductionFilter(builder);
1014}
1015
1016static inline float nvnSamplerBuilderGetLodSnap(const NVNsamplerBuilder* builder) {
1017 return pfnc_nvnSamplerBuilderGetLodSnap(builder);
1018}
1019
1020static inline NVNboolean nvnSamplerInitialize(NVNsampler* sampler,
1021 const NVNsamplerBuilder* builder) {
1022 return pfnc_nvnSamplerInitialize(sampler, builder);
1023}
1024
1025static inline void nvnSamplerFinalize(NVNsampler* sampler) {
1026 pfnc_nvnSamplerFinalize(sampler);
1027}
1028
1029static inline void nvnSamplerSetDebugLabel(NVNsampler* sampler, const char* label) {
1030 pfnc_nvnSamplerSetDebugLabel(sampler, label);
1031}
1032
1033static inline void nvnSamplerGetMinMagFilter(const NVNsampler* sampler, NVNminFilter* min,
1034 NVNmagFilter* mag) {
1035 pfnc_nvnSamplerGetMinMagFilter(sampler, min, mag);
1036}
1037
1038static inline void nvnSamplerGetWrapMode(const NVNsampler* sampler, NVNwrapMode* s, NVNwrapMode* t,
1039 NVNwrapMode* r) {
1040 pfnc_nvnSamplerGetWrapMode(sampler, s, t, r);
1041}
1042
1043static inline void nvnSamplerGetLodClamp(const NVNsampler* sampler, float* min, float* max) {
1044 pfnc_nvnSamplerGetLodClamp(sampler, min, max);
1045}
1046
1047static inline float nvnSamplerGetLodBias(const NVNsampler* sampler) {
1048 return pfnc_nvnSamplerGetLodBias(sampler);
1049}
1050
1051static inline void nvnSamplerGetCompare(const NVNsampler* sampler, NVNcompareMode* mode,
1052 NVNcompareFunc* func) {
1053 pfnc_nvnSamplerGetCompare(sampler, mode, func);
1054}
1055
1056static inline void nvnSamplerGetBorderColor(const NVNsampler* sampler, float* borderColor) {
1057 pfnc_nvnSamplerGetBorderColor(sampler, borderColor);
1058}
1059
1060static inline void nvnSamplerGetBorderColori(const NVNsampler* sampler, int* borderColor) {
1061 pfnc_nvnSamplerGetBorderColori(sampler, borderColor);
1062}
1063
1064static inline void nvnSamplerGetBorderColorui(const NVNsampler* sampler, uint32_t* borderColor) {
1065 pfnc_nvnSamplerGetBorderColorui(sampler, borderColor);
1066}
1067
1068static inline float nvnSamplerGetMaxAnisotropy(const NVNsampler* sampler) {
1069 return pfnc_nvnSamplerGetMaxAnisotropy(sampler);
1070}
1071
1072static inline NVNsamplerReduction nvnSamplerGetReductionFilter(const NVNsampler* sampler) {
1073 return pfnc_nvnSamplerGetReductionFilter(sampler);
1074}
1075
1076static inline NVNboolean nvnSamplerCompare(const NVNsampler* sampler1, const NVNsampler* sampler2) {
1077 return pfnc_nvnSamplerCompare(sampler1, sampler2);
1078}
1079
1080static inline uint64_t nvnSamplerGetDebugID(const NVNsampler* sampler) {
1081 return pfnc_nvnSamplerGetDebugID(sampler);
1082}
1083
1084static inline void nvnBlendStateSetDefaults(NVNblendState* blend) {
1085 pfnc_nvnBlendStateSetDefaults(blend);
1086}
1087
1088static inline void nvnBlendStateSetBlendTarget(NVNblendState* blend, int target) {
1089 pfnc_nvnBlendStateSetBlendTarget(blend, target);
1090}
1091
1092static inline void nvnBlendStateSetBlendFunc(NVNblendState* blend, NVNblendFunc srcFunc,
1093 NVNblendFunc dstFunc, NVNblendFunc srcFuncAlpha,
1094 NVNblendFunc dstFuncAlpha) {
1095 pfnc_nvnBlendStateSetBlendFunc(blend, srcFunc, dstFunc, srcFuncAlpha, dstFuncAlpha);
1096}
1097
1098static inline void nvnBlendStateSetBlendEquation(NVNblendState* blend, NVNblendEquation modeRGB,
1099 NVNblendEquation modeAlpha) {
1100 pfnc_nvnBlendStateSetBlendEquation(blend, modeRGB, modeAlpha);
1101}
1102
1103static inline void nvnBlendStateSetAdvancedMode(NVNblendState* blend, NVNblendAdvancedMode mode) {
1104 pfnc_nvnBlendStateSetAdvancedMode(blend, mode);
1105}
1106
1107static inline void nvnBlendStateSetAdvancedOverlap(NVNblendState* blend,
1108 NVNblendAdvancedOverlap overlap) {
1109 pfnc_nvnBlendStateSetAdvancedOverlap(blend, overlap);
1110}
1111
1112static inline void nvnBlendStateSetAdvancedPremultipliedSrc(NVNblendState* blend, NVNboolean b) {
1113 pfnc_nvnBlendStateSetAdvancedPremultipliedSrc(blend, b);
1114}
1115
1116static inline void nvnBlendStateSetAdvancedNormalizedDst(NVNblendState* blend, NVNboolean b) {
1117 pfnc_nvnBlendStateSetAdvancedNormalizedDst(blend, b);
1118}
1119
1120static inline int nvnBlendStateGetBlendTarget(const NVNblendState* blend) {
1121 return pfnc_nvnBlendStateGetBlendTarget(blend);
1122}
1123
1124static inline void nvnBlendStateGetBlendFunc(const NVNblendState* blend, NVNblendFunc* srcFunc,
1125 NVNblendFunc* dstFunc, NVNblendFunc* srcFuncAlpha,
1126 NVNblendFunc* dstFuncAlpha) {
1127 pfnc_nvnBlendStateGetBlendFunc(blend, srcFunc, dstFunc, srcFuncAlpha, dstFuncAlpha);
1128}
1129
1130static inline void nvnBlendStateGetBlendEquation(const NVNblendState* blend,
1131 NVNblendEquation* modeRGB,
1132 NVNblendEquation* modeAlpha) {
1133 pfnc_nvnBlendStateGetBlendEquation(blend, modeRGB, modeAlpha);
1134}
1135
1136static inline NVNblendAdvancedMode nvnBlendStateGetAdvancedMode(const NVNblendState* blend) {
1137 return pfnc_nvnBlendStateGetAdvancedMode(blend);
1138}
1139
1140static inline NVNblendAdvancedOverlap nvnBlendStateGetAdvancedOverlap(const NVNblendState* blend) {
1141 return pfnc_nvnBlendStateGetAdvancedOverlap(blend);
1142}
1143
1144static inline NVNboolean nvnBlendStateGetAdvancedPremultipliedSrc(const NVNblendState* blend) {
1145 return pfnc_nvnBlendStateGetAdvancedPremultipliedSrc(blend);
1146}
1147
1148static inline NVNboolean nvnBlendStateGetAdvancedNormalizedDst(const NVNblendState* blend) {
1149 return pfnc_nvnBlendStateGetAdvancedNormalizedDst(blend);
1150}
1151
1152static inline void nvnColorStateSetDefaults(NVNcolorState* color) {
1153 pfnc_nvnColorStateSetDefaults(color);
1154}
1155
1156static inline void nvnColorStateSetBlendEnable(NVNcolorState* color, int index, NVNboolean enable) {
1157 pfnc_nvnColorStateSetBlendEnable(color, index, enable);
1158}
1159
1160static inline void nvnColorStateSetLogicOp(NVNcolorState* color, NVNlogicOp logicOp) {
1161 pfnc_nvnColorStateSetLogicOp(color, logicOp);
1162}
1163
1164static inline void nvnColorStateSetAlphaTest(NVNcolorState* color, NVNalphaFunc alphaFunc) {
1165 pfnc_nvnColorStateSetAlphaTest(color, alphaFunc);
1166}
1167
1168static inline NVNboolean nvnColorStateGetBlendEnable(const NVNcolorState* color, int index) {
1169 return pfnc_nvnColorStateGetBlendEnable(color, index);
1170}
1171
1172static inline NVNlogicOp nvnColorStateGetLogicOp(const NVNcolorState* color) {
1173 return pfnc_nvnColorStateGetLogicOp(color);
1174}
1175
1176static inline NVNalphaFunc nvnColorStateGetAlphaTest(const NVNcolorState* color) {
1177 return pfnc_nvnColorStateGetAlphaTest(color);
1178}
1179
1180static inline void nvnChannelMaskStateSetDefaults(NVNchannelMaskState* channelMask) {
1181 pfnc_nvnChannelMaskStateSetDefaults(channelMask);
1182}
1183
1184static inline void nvnChannelMaskStateSetChannelMask(NVNchannelMaskState* channelMask, int index,
1185 NVNboolean r, NVNboolean g, NVNboolean b,
1186 NVNboolean a) {
1187 pfnc_nvnChannelMaskStateSetChannelMask(channelMask, index, r, g, b, a);
1188}
1189
1190static inline void nvnChannelMaskStateGetChannelMask(const NVNchannelMaskState* channelMask,
1191 int index, NVNboolean* r, NVNboolean* g,
1192 NVNboolean* b, NVNboolean* a) {
1193 pfnc_nvnChannelMaskStateGetChannelMask(channelMask, index, r, g, b, a);
1194}
1195
1196static inline void nvnMultisampleStateSetDefaults(NVNmultisampleState* multisample) {
1197 pfnc_nvnMultisampleStateSetDefaults(multisample);
1198}
1199
1200static inline void nvnMultisampleStateSetMultisampleEnable(NVNmultisampleState* multisample,
1201 NVNboolean enable) {
1202 pfnc_nvnMultisampleStateSetMultisampleEnable(multisample, enable);
1203}
1204
1205static inline void nvnMultisampleStateSetSamples(NVNmultisampleState* multisample, int samples) {
1206 pfnc_nvnMultisampleStateSetSamples(multisample, samples);
1207}
1208
1209static inline void nvnMultisampleStateSetAlphaToCoverageEnable(NVNmultisampleState* multisample,
1210 NVNboolean enable) {
1211 pfnc_nvnMultisampleStateSetAlphaToCoverageEnable(multisample, enable);
1212}
1213
1214static inline void nvnMultisampleStateSetAlphaToCoverageDither(NVNmultisampleState* multisample,
1215 NVNboolean enable) {
1216 pfnc_nvnMultisampleStateSetAlphaToCoverageDither(multisample, enable);
1217}
1218
1219static inline NVNboolean
1220nvnMultisampleStateGetMultisampleEnable(const NVNmultisampleState* multisample) {
1221 return pfnc_nvnMultisampleStateGetMultisampleEnable(multisample);
1222}
1223
1224static inline int nvnMultisampleStateGetSamples(const NVNmultisampleState* multisample) {
1225 return pfnc_nvnMultisampleStateGetSamples(multisample);
1226}
1227
1228static inline NVNboolean
1229nvnMultisampleStateGetAlphaToCoverageEnable(const NVNmultisampleState* multisample) {
1230 return pfnc_nvnMultisampleStateGetAlphaToCoverageEnable(multisample);
1231}
1232
1233static inline NVNboolean
1234nvnMultisampleStateGetAlphaToCoverageDither(const NVNmultisampleState* multisample) {
1235 return pfnc_nvnMultisampleStateGetAlphaToCoverageDither(multisample);
1236}
1237
1238static inline void nvnMultisampleStateSetRasterSamples(NVNmultisampleState* multisample,
1239 int samples) {
1240 pfnc_nvnMultisampleStateSetRasterSamples(multisample, samples);
1241}
1242
1243static inline int nvnMultisampleStateGetRasterSamples(NVNmultisampleState* multisample) {
1244 return pfnc_nvnMultisampleStateGetRasterSamples(multisample);
1245}
1246
1247static inline void nvnMultisampleStateSetCoverageModulationMode(NVNmultisampleState* multisample,
1248 NVNcoverageModulationMode mode) {
1249 pfnc_nvnMultisampleStateSetCoverageModulationMode(multisample, mode);
1250}
1251
1252static inline NVNcoverageModulationMode
1253nvnMultisampleStateGetCoverageModulationMode(const NVNmultisampleState* multisample) {
1254 return pfnc_nvnMultisampleStateGetCoverageModulationMode(multisample);
1255}
1256
1257static inline void nvnMultisampleStateSetCoverageToColorEnable(NVNmultisampleState* multisample,
1258 NVNboolean enable) {
1259 pfnc_nvnMultisampleStateSetCoverageToColorEnable(multisample, enable);
1260}
1261
1262static inline NVNboolean
1263nvnMultisampleStateGetCoverageToColorEnable(const NVNmultisampleState* multisample) {
1264 return pfnc_nvnMultisampleStateGetCoverageToColorEnable(multisample);
1265}
1266
1267static inline void nvnMultisampleStateSetCoverageToColorOutput(NVNmultisampleState* multisample,
1268 int i) {
1269 pfnc_nvnMultisampleStateSetCoverageToColorOutput(multisample, i);
1270}
1271
1272static inline int
1273nvnMultisampleStateGetCoverageToColorOutput(const NVNmultisampleState* multisample) {
1274 return pfnc_nvnMultisampleStateGetCoverageToColorOutput(multisample);
1275}
1276
1277static inline void nvnMultisampleStateSetSampleLocationsEnable(NVNmultisampleState* multisample,
1278 NVNboolean enable) {
1279 pfnc_nvnMultisampleStateSetSampleLocationsEnable(multisample, enable);
1280}
1281
1282static inline NVNboolean
1283nvnMultisampleStateGetSampleLocationsEnable(const NVNmultisampleState* multisample) {
1284 return pfnc_nvnMultisampleStateGetSampleLocationsEnable(multisample);
1285}
1286
1287static inline void nvnMultisampleStateGetSampleLocationsGrid(NVNmultisampleState* multisample,
1288 int* w, int* h) {
1289 pfnc_nvnMultisampleStateGetSampleLocationsGrid(multisample, w, h);
1290}
1291
1292static inline void nvnMultisampleStateSetSampleLocationsGridEnable(NVNmultisampleState* multisample,
1293 NVNboolean enable) {
1294 pfnc_nvnMultisampleStateSetSampleLocationsGridEnable(multisample, enable);
1295}
1296
1297static inline NVNboolean
1298nvnMultisampleStateGetSampleLocationsGridEnable(const NVNmultisampleState* multisample) {
1299 return pfnc_nvnMultisampleStateGetSampleLocationsGridEnable(multisample);
1300}
1301
1302static inline void nvnMultisampleStateSetSampleLocations(NVNmultisampleState* multisample, int i1,
1303 int i2, const float* f) {
1304 pfnc_nvnMultisampleStateSetSampleLocations(multisample, i1, i2, f);
1305}
1306
1307static inline void nvnPolygonStateSetDefaults(NVNpolygonState* polygon) {
1308 pfnc_nvnPolygonStateSetDefaults(polygon);
1309}
1310
1311static inline void nvnPolygonStateSetCullFace(NVNpolygonState* polygon, NVNface face) {
1312 pfnc_nvnPolygonStateSetCullFace(polygon, face);
1313}
1314
1315static inline void nvnPolygonStateSetFrontFace(NVNpolygonState* polygon, NVNfrontFace face) {
1316 pfnc_nvnPolygonStateSetFrontFace(polygon, face);
1317}
1318
1319static inline void nvnPolygonStateSetPolygonMode(NVNpolygonState* polygon,
1320 NVNpolygonMode polygonMode) {
1321 pfnc_nvnPolygonStateSetPolygonMode(polygon, polygonMode);
1322}
1323
1324static inline void nvnPolygonStateSetPolygonOffsetEnables(NVNpolygonState* polygon, int enables) {
1325 pfnc_nvnPolygonStateSetPolygonOffsetEnables(polygon, enables);
1326}
1327
1328static inline NVNface nvnPolygonStateGetCullFace(const NVNpolygonState* polygon) {
1329 return pfnc_nvnPolygonStateGetCullFace(polygon);
1330}
1331
1332static inline NVNfrontFace nvnPolygonStateGetFrontFace(const NVNpolygonState* polygon) {
1333 return pfnc_nvnPolygonStateGetFrontFace(polygon);
1334}
1335
1336static inline NVNpolygonMode nvnPolygonStateGetPolygonMode(const NVNpolygonState* polygon) {
1337 return pfnc_nvnPolygonStateGetPolygonMode(polygon);
1338}
1339
1340static inline NVNpolygonOffsetEnable
1341nvnPolygonStateGetPolygonOffsetEnables(const NVNpolygonState* polygon) {
1342 return pfnc_nvnPolygonStateGetPolygonOffsetEnables(polygon);
1343}
1344
1345static inline void nvnDepthStencilStateSetDefaults(NVNdepthStencilState* depthStencil) {
1346 pfnc_nvnDepthStencilStateSetDefaults(depthStencil);
1347}
1348
1349static inline void nvnDepthStencilStateSetDepthTestEnable(NVNdepthStencilState* depthStencil,
1350 NVNboolean enable) {
1351 pfnc_nvnDepthStencilStateSetDepthTestEnable(depthStencil, enable);
1352}
1353
1354static inline void nvnDepthStencilStateSetDepthWriteEnable(NVNdepthStencilState* depthStencil,
1355 NVNboolean enable) {
1356 pfnc_nvnDepthStencilStateSetDepthWriteEnable(depthStencil, enable);
1357}
1358
1359static inline void nvnDepthStencilStateSetDepthFunc(NVNdepthStencilState* depthStencil,
1360 NVNdepthFunc func) {
1361 pfnc_nvnDepthStencilStateSetDepthFunc(depthStencil, func);
1362}
1363
1364static inline void nvnDepthStencilStateSetStencilTestEnable(NVNdepthStencilState* depthStencil,
1365 NVNboolean enable) {
1366 pfnc_nvnDepthStencilStateSetStencilTestEnable(depthStencil, enable);
1367}
1368
1369static inline void nvnDepthStencilStateSetStencilFunc(NVNdepthStencilState* depthStencil,
1370 NVNface faces, NVNstencilFunc func) {
1371 pfnc_nvnDepthStencilStateSetStencilFunc(depthStencil, faces, func);
1372}
1373
1374static inline void nvnDepthStencilStateSetStencilOp(NVNdepthStencilState* depthStencil,
1375 NVNface faces, NVNstencilOp fail,
1376 NVNstencilOp depthFail,
1377 NVNstencilOp depthPass) {
1378 pfnc_nvnDepthStencilStateSetStencilOp(depthStencil, faces, fail, depthFail, depthPass);
1379}
1380
1381static inline NVNboolean
1382nvnDepthStencilStateGetDepthTestEnable(const NVNdepthStencilState* depthStencil) {
1383 return pfnc_nvnDepthStencilStateGetDepthTestEnable(depthStencil);
1384}
1385
1386static inline NVNboolean
1387nvnDepthStencilStateGetDepthWriteEnable(const NVNdepthStencilState* depthStencil) {
1388 return pfnc_nvnDepthStencilStateGetDepthWriteEnable(depthStencil);
1389}
1390
1391static inline NVNdepthFunc
1392nvnDepthStencilStateGetDepthFunc(const NVNdepthStencilState* depthStencil) {
1393 return pfnc_nvnDepthStencilStateGetDepthFunc(depthStencil);
1394}
1395
1396static inline NVNboolean
1397nvnDepthStencilStateGetStencilTestEnable(const NVNdepthStencilState* depthStencil) {
1398 return pfnc_nvnDepthStencilStateGetStencilTestEnable(depthStencil);
1399}
1400
1401static inline NVNstencilFunc
1402nvnDepthStencilStateGetStencilFunc(const NVNdepthStencilState* depthStencil, NVNface faces) {
1403 return pfnc_nvnDepthStencilStateGetStencilFunc(depthStencil, faces);
1404}
1405
1406static inline void nvnDepthStencilStateGetStencilOp(const NVNdepthStencilState* depthStencil,
1407 NVNface faces, NVNstencilOp* fail,
1408 NVNstencilOp* depthFail,
1409 NVNstencilOp* depthPass) {
1410 pfnc_nvnDepthStencilStateGetStencilOp(depthStencil, faces, fail, depthFail, depthPass);
1411}
1412
1413static inline void nvnVertexAttribStateSetDefaults(NVNvertexAttribState* attrib) {
1414 pfnc_nvnVertexAttribStateSetDefaults(attrib);
1415}
1416
1417static inline void nvnVertexAttribStateSetFormat(NVNvertexAttribState* attrib, NVNformat format,
1418 ptrdiff_t relativeOffset) {
1419 pfnc_nvnVertexAttribStateSetFormat(attrib, format, relativeOffset);
1420}
1421
1422static inline void nvnVertexAttribStateSetStreamIndex(NVNvertexAttribState* attrib,
1423 int streamIndex) {
1424 pfnc_nvnVertexAttribStateSetStreamIndex(attrib, streamIndex);
1425}
1426
1427static inline void nvnVertexAttribStateGetFormat(const NVNvertexAttribState* attrib,
1428 NVNformat* format, ptrdiff_t* relativeOffset) {
1429 pfnc_nvnVertexAttribStateGetFormat(attrib, format, relativeOffset);
1430}
1431
1432static inline int nvnVertexAttribStateGetStreamIndex(const NVNvertexAttribState* attrib) {
1433 return pfnc_nvnVertexAttribStateGetStreamIndex(attrib);
1434}
1435
1436static inline void nvnVertexStreamStateSetDefaults(NVNvertexStreamState* stream) {
1437 pfnc_nvnVertexStreamStateSetDefaults(stream);
1438}
1439
1440static inline void nvnVertexStreamStateSetStride(NVNvertexStreamState* stream, ptrdiff_t stride) {
1441 pfnc_nvnVertexStreamStateSetStride(stream, stride);
1442}
1443
1444static inline void nvnVertexStreamStateSetDivisor(NVNvertexStreamState* stream, int divisor) {
1445 pfnc_nvnVertexStreamStateSetDivisor(stream, divisor);
1446}
1447
1448static inline ptrdiff_t nvnVertexStreamStateGetStride(const NVNvertexStreamState* stream) {
1449 return pfnc_nvnVertexStreamStateGetStride(stream);
1450}
1451
1452static inline int nvnVertexStreamStateGetDivisor(const NVNvertexStreamState* stream) {
1453 return pfnc_nvnVertexStreamStateGetDivisor(stream);
1454}
1455
1456static inline NVNboolean nvnCommandBufferInitialize(NVNcommandBuffer* cmdBuf, NVNdevice* device) {
1457 return pfnc_nvnCommandBufferInitialize(cmdBuf, device);
1458}
1459
1460static inline void nvnCommandBufferFinalize(NVNcommandBuffer* cmdBuf) {
1461 pfnc_nvnCommandBufferFinalize(cmdBuf);
1462}
1463
1464static inline void nvnCommandBufferSetDebugLabel(NVNcommandBuffer* cmdBuf, const char* label) {
1465 pfnc_nvnCommandBufferSetDebugLabel(cmdBuf, label);
1466}
1467
1468static inline void
1469nvnCommandBufferSetMemoryCallback(NVNcommandBuffer* cmdBuf,
1470 PFNNVNCOMMANDBUFFERMEMORYCALLBACKPROC callback) {
1471 pfnc_nvnCommandBufferSetMemoryCallback(cmdBuf, callback);
1472}
1473
1474static inline void nvnCommandBufferSetMemoryCallbackData(NVNcommandBuffer* cmdBuf,
1475 void* callbackData) {
1476 pfnc_nvnCommandBufferSetMemoryCallbackData(cmdBuf, callbackData);
1477}
1478
1479static inline void nvnCommandBufferAddCommandMemory(NVNcommandBuffer* cmdBuf,
1480 const NVNmemoryPool* pool, ptrdiff_t offset,
1481 size_t size) {
1482 pfnc_nvnCommandBufferAddCommandMemory(cmdBuf, pool, offset, size);
1483}
1484
1485static inline void nvnCommandBufferAddControlMemory(NVNcommandBuffer* cmdBuf, void* memory,
1486 size_t size) {
1487 pfnc_nvnCommandBufferAddControlMemory(cmdBuf, memory, size);
1488}
1489
1490static inline size_t nvnCommandBufferGetCommandMemorySize(const NVNcommandBuffer* cmdBuf) {
1491 return pfnc_nvnCommandBufferGetCommandMemorySize(cmdBuf);
1492}
1493
1494static inline size_t nvnCommandBufferGetCommandMemoryUsed(const NVNcommandBuffer* cmdBuf) {
1495 return pfnc_nvnCommandBufferGetCommandMemoryUsed(cmdBuf);
1496}
1497
1498static inline size_t nvnCommandBufferGetCommandMemoryFree(const NVNcommandBuffer* cmdBuf) {
1499 return pfnc_nvnCommandBufferGetCommandMemoryFree(cmdBuf);
1500}
1501
1502static inline size_t nvnCommandBufferGetControlMemorySize(const NVNcommandBuffer* cmdBuf) {
1503 return pfnc_nvnCommandBufferGetControlMemorySize(cmdBuf);
1504}
1505
1506static inline size_t nvnCommandBufferGetControlMemoryUsed(const NVNcommandBuffer* cmdBuf) {
1507 return pfnc_nvnCommandBufferGetControlMemoryUsed(cmdBuf);
1508}
1509
1510static inline size_t nvnCommandBufferGetControlMemoryFree(const NVNcommandBuffer* cmdBuf) {
1511 return pfnc_nvnCommandBufferGetControlMemoryFree(cmdBuf);
1512}
1513
1514static inline void nvnCommandBufferBeginRecording(NVNcommandBuffer* cmdBuf) {
1515 pfnc_nvnCommandBufferBeginRecording(cmdBuf);
1516}
1517
1518static inline NVNcommandHandle nvnCommandBufferEndRecording(NVNcommandBuffer* cmdBuf) {
1519 return pfnc_nvnCommandBufferEndRecording(cmdBuf);
1520}
1521
1522static inline void nvnCommandBufferCallCommands(NVNcommandBuffer* cmdBuf, int numCommands,
1523 const NVNcommandHandle* handles) {
1524 pfnc_nvnCommandBufferCallCommands(cmdBuf, numCommands, handles);
1525}
1526
1527static inline void nvnCommandBufferCopyCommands(NVNcommandBuffer* cmdBuf, int numCommands,
1528 const NVNcommandHandle* handles) {
1529 pfnc_nvnCommandBufferCopyCommands(cmdBuf, numCommands, handles);
1530}
1531
1532static inline void nvnCommandBufferBindBlendState(NVNcommandBuffer* cmdBuf,
1533 const NVNblendState* blend) {
1534 pfnc_nvnCommandBufferBindBlendState(cmdBuf, blend);
1535}
1536
1537static inline void nvnCommandBufferBindChannelMaskState(NVNcommandBuffer* cmdBuf,
1538 const NVNchannelMaskState* channelMask) {
1539 pfnc_nvnCommandBufferBindChannelMaskState(cmdBuf, channelMask);
1540}
1541
1542static inline void nvnCommandBufferBindColorState(NVNcommandBuffer* cmdBuf,
1543 const NVNcolorState* color) {
1544 pfnc_nvnCommandBufferBindColorState(cmdBuf, color);
1545}
1546
1547static inline void nvnCommandBufferBindMultisampleState(NVNcommandBuffer* cmdBuf,
1548 const NVNmultisampleState* multisample) {
1549 pfnc_nvnCommandBufferBindMultisampleState(cmdBuf, multisample);
1550}
1551
1552static inline void nvnCommandBufferBindPolygonState(NVNcommandBuffer* cmdBuf,
1553 const NVNpolygonState* polygon) {
1554 pfnc_nvnCommandBufferBindPolygonState(cmdBuf, polygon);
1555}
1556
1557static inline void nvnCommandBufferBindDepthStencilState(NVNcommandBuffer* cmdBuf,
1558 const NVNdepthStencilState* depthStencil) {
1559 pfnc_nvnCommandBufferBindDepthStencilState(cmdBuf, depthStencil);
1560}
1561
1562static inline void nvnCommandBufferBindVertexAttribState(NVNcommandBuffer* cmdBuf, int numAttribs,
1563 const NVNvertexAttribState* attribs) {
1564 pfnc_nvnCommandBufferBindVertexAttribState(cmdBuf, numAttribs, attribs);
1565}
1566
1567static inline void nvnCommandBufferBindVertexStreamState(NVNcommandBuffer* cmdBuf, int numStreams,
1568 const NVNvertexStreamState* streams) {
1569 pfnc_nvnCommandBufferBindVertexStreamState(cmdBuf, numStreams, streams);
1570}
1571
1572static inline void nvnCommandBufferBindProgram(NVNcommandBuffer* cmdBuf, const NVNprogram* program,
1573 int stages) {
1574 pfnc_nvnCommandBufferBindProgram(cmdBuf, program, stages);
1575}
1576
1577static inline void nvnCommandBufferBindVertexBuffer(NVNcommandBuffer* cmdBuf, int index,
1578 NVNbufferAddress buffer, size_t size) {
1579 pfnc_nvnCommandBufferBindVertexBuffer(cmdBuf, index, buffer, size);
1580}
1581
1582static inline void nvnCommandBufferBindVertexBuffers(NVNcommandBuffer* cmdBuf, int first, int count,
1583 const NVNbufferRange* buffers) {
1584 pfnc_nvnCommandBufferBindVertexBuffers(cmdBuf, first, count, buffers);
1585}
1586
1587static inline void nvnCommandBufferBindUniformBuffer(NVNcommandBuffer* cmdBuf, NVNshaderStage stage,
1588 int index, NVNbufferAddress buffer,
1589 size_t size) {
1590 pfnc_nvnCommandBufferBindUniformBuffer(cmdBuf, stage, index, buffer, size);
1591}
1592
1593static inline void nvnCommandBufferBindUniformBuffers(NVNcommandBuffer* cmdBuf,
1594 NVNshaderStage stage, int first, int count,
1595 const NVNbufferRange* buffers) {
1596 pfnc_nvnCommandBufferBindUniformBuffers(cmdBuf, stage, first, count, buffers);
1597}
1598
1599static inline void nvnCommandBufferBindTransformFeedbackBuffer(NVNcommandBuffer* cmdBuf, int index,
1600 NVNbufferAddress buffer,
1601 size_t size) {
1602 pfnc_nvnCommandBufferBindTransformFeedbackBuffer(cmdBuf, index, buffer, size);
1603}
1604
1605static inline void nvnCommandBufferBindTransformFeedbackBuffers(NVNcommandBuffer* cmdBuf, int first,
1606 int count,
1607 const NVNbufferRange* buffers) {
1608 pfnc_nvnCommandBufferBindTransformFeedbackBuffers(cmdBuf, first, count, buffers);
1609}
1610
1611static inline void nvnCommandBufferBindStorageBuffer(NVNcommandBuffer* cmdBuf, NVNshaderStage stage,
1612 int index, NVNbufferAddress buffer,
1613 size_t size) {
1614 pfnc_nvnCommandBufferBindStorageBuffer(cmdBuf, stage, index, buffer, size);
1615}
1616
1617static inline void nvnCommandBufferBindStorageBuffers(NVNcommandBuffer* cmdBuf,
1618 NVNshaderStage stage, int first, int count,
1619 const NVNbufferRange* buffers) {
1620 pfnc_nvnCommandBufferBindStorageBuffers(cmdBuf, stage, first, count, buffers);
1621}
1622
1623static inline void nvnCommandBufferBindTexture(NVNcommandBuffer* cmdBuf, NVNshaderStage stage,
1624 int index, NVNtextureHandle texture) {
1625 pfnc_nvnCommandBufferBindTexture(cmdBuf, stage, index, texture);
1626}
1627
1628static inline void nvnCommandBufferBindTextures(NVNcommandBuffer* cmdBuf, NVNshaderStage stage,
1629 int first, int count,
1630 const NVNtextureHandle* textures) {
1631 pfnc_nvnCommandBufferBindTextures(cmdBuf, stage, first, count, textures);
1632}
1633
1634static inline void nvnCommandBufferBindImage(NVNcommandBuffer* cmdBuf, NVNshaderStage stage,
1635 int index, NVNimageHandle image) {
1636 pfnc_nvnCommandBufferBindImage(cmdBuf, stage, index, image);
1637}
1638
1639static inline void nvnCommandBufferBindImages(NVNcommandBuffer* cmdBuf, NVNshaderStage stage,
1640 int first, int count, const NVNimageHandle* images) {
1641 pfnc_nvnCommandBufferBindImages(cmdBuf, stage, first, count, images);
1642}
1643
1644static inline void nvnCommandBufferSetPatchSize(NVNcommandBuffer* cmdBuf, int i) {
1645 pfnc_nvnCommandBufferSetPatchSize(cmdBuf, i);
1646}
1647
1648static inline void nvnCommandBufferSetInnerTessellationLevels(NVNcommandBuffer* cmdBuf,
1649 const float* f) {
1650 pfnc_nvnCommandBufferSetInnerTessellationLevels(cmdBuf, f);
1651}
1652
1653static inline void nvnCommandBufferSetOuterTessellationLevels(NVNcommandBuffer* cmdBuf,
1654 const float* f) {
1655 pfnc_nvnCommandBufferSetOuterTessellationLevels(cmdBuf, f);
1656}
1657
1658static inline void nvnCommandBufferSetPrimitiveRestart(NVNcommandBuffer* cmdBuf, NVNboolean b,
1659 int i) {
1660 pfnc_nvnCommandBufferSetPrimitiveRestart(cmdBuf, b, i);
1661}
1662
1663static inline void nvnCommandBufferBeginTransformFeedback(NVNcommandBuffer* cmdBuf,
1664 NVNbufferAddress buffer) {
1665 pfnc_nvnCommandBufferBeginTransformFeedback(cmdBuf, buffer);
1666}
1667
1668static inline void nvnCommandBufferEndTransformFeedback(NVNcommandBuffer* cmdBuf,
1669 NVNbufferAddress buffer) {
1670 pfnc_nvnCommandBufferEndTransformFeedback(cmdBuf, buffer);
1671}
1672
1673static inline void nvnCommandBufferPauseTransformFeedback(NVNcommandBuffer* cmdBuf,
1674 NVNbufferAddress buffer) {
1675 pfnc_nvnCommandBufferPauseTransformFeedback(cmdBuf, buffer);
1676}
1677
1678static inline void nvnCommandBufferResumeTransformFeedback(NVNcommandBuffer* cmdBuf,
1679 NVNbufferAddress buffer) {
1680 pfnc_nvnCommandBufferResumeTransformFeedback(cmdBuf, buffer);
1681}
1682
1683static inline void nvnCommandBufferDrawTransformFeedback(NVNcommandBuffer* cmdBuf,
1684 NVNdrawPrimitive mode,
1685 NVNbufferAddress buffer) {
1686 pfnc_nvnCommandBufferDrawTransformFeedback(cmdBuf, mode, buffer);
1687}
1688
1689static inline void nvnCommandBufferDrawArrays(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode,
1690 int first, int count) {
1691 pfnc_nvnCommandBufferDrawArrays(cmdBuf, mode, first, count);
1692}
1693
1694static inline void nvnCommandBufferDrawElements(NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode,
1695 NVNindexType type, int count,
1696 NVNbufferAddress indexBuffer) {
1697 pfnc_nvnCommandBufferDrawElements(cmdBuf, mode, type, count, indexBuffer);
1698}
1699
1700static inline void nvnCommandBufferDrawElementsBaseVertex(NVNcommandBuffer* cmdBuf,
1701 NVNdrawPrimitive mode, NVNindexType type,
1702 int count, NVNbufferAddress indexBuffer,
1703 int baseVertex) {
1704 pfnc_nvnCommandBufferDrawElementsBaseVertex(cmdBuf, mode, type, count, indexBuffer, baseVertex);
1705}
1706
1707static inline void nvnCommandBufferDrawArraysInstanced(NVNcommandBuffer* cmdBuf,
1708 NVNdrawPrimitive mode, int first, int count,
1709 int baseInstance, int instanceCount) {
1710 pfnc_nvnCommandBufferDrawArraysInstanced(cmdBuf, mode, first, count, baseInstance,
1711 instanceCount);
1712}
1713
1714static inline void nvnCommandBufferDrawElementsInstanced(NVNcommandBuffer* cmdBuf,
1715 NVNdrawPrimitive mode, NVNindexType type,
1716 int count, NVNbufferAddress indexBuffer,
1717 int baseVertex, int baseInstance,
1718 int instanceCount) {
1719 pfnc_nvnCommandBufferDrawElementsInstanced(cmdBuf, mode, type, count, indexBuffer, baseVertex,
1720 baseInstance, instanceCount);
1721}
1722
1723static inline void nvnCommandBufferDrawArraysIndirect(NVNcommandBuffer* cmdBuf,
1724 NVNdrawPrimitive mode,
1725 NVNbufferAddress buffer) {
1726 pfnc_nvnCommandBufferDrawArraysIndirect(cmdBuf, mode, buffer);
1727}
1728
1729static inline void nvnCommandBufferDrawElementsIndirect(NVNcommandBuffer* cmdBuf,
1730 NVNdrawPrimitive mode, NVNindexType type,
1731 NVNbufferAddress buffer1,
1732 NVNbufferAddress buffer2) {
1733 pfnc_nvnCommandBufferDrawElementsIndirect(cmdBuf, mode, type, buffer1, buffer2);
1734}
1735
1736static inline void nvnCommandBufferMultiDrawArraysIndirectCount(NVNcommandBuffer* cmdBuf,
1737 NVNdrawPrimitive mode,
1738 NVNbufferAddress buffer1,
1739 NVNbufferAddress buffer2, int i,
1740 ptrdiff_t o) {
1741 pfnc_nvnCommandBufferMultiDrawArraysIndirectCount(cmdBuf, mode, buffer1, buffer2, i, o);
1742}
1743
1744static inline void nvnCommandBufferMultiDrawElementsIndirectCount(
1745 NVNcommandBuffer* cmdBuf, NVNdrawPrimitive mode, NVNindexType type, NVNbufferAddress buffer1,
1746 NVNbufferAddress buffer2, NVNbufferAddress buffer3, int i, ptrdiff_t o) {
1747 pfnc_nvnCommandBufferMultiDrawElementsIndirectCount(cmdBuf, mode, type, buffer1, buffer2,
1748 buffer3, i, o);
1749}
1750
1751static inline void nvnCommandBufferClearColor(NVNcommandBuffer* cmdBuf, int index,
1752 const float* color, int mask) {
1753 pfnc_nvnCommandBufferClearColor(cmdBuf, index, color, mask);
1754}
1755
1756static inline void nvnCommandBufferClearColori(NVNcommandBuffer* cmdBuf, int index,
1757 const int* color, int mask) {
1758 pfnc_nvnCommandBufferClearColori(cmdBuf, index, color, mask);
1759}
1760
1761static inline void nvnCommandBufferClearColorui(NVNcommandBuffer* cmdBuf, int index,
1762 const uint32_t* color, int mask) {
1763 pfnc_nvnCommandBufferClearColorui(cmdBuf, index, color, mask);
1764}
1765
1766static inline void nvnCommandBufferClearDepthStencil(NVNcommandBuffer* cmdBuf, float depthValue,
1767 NVNboolean depthMask, int stencilValue,
1768 int stencilMask) {
1769 pfnc_nvnCommandBufferClearDepthStencil(cmdBuf, depthValue, depthMask, stencilValue,
1770 stencilMask);
1771}
1772
1773static inline void nvnCommandBufferDispatchCompute(NVNcommandBuffer* cmdBuf, int groupsX,
1774 int groupsY, int groupsZ) {
1775 pfnc_nvnCommandBufferDispatchCompute(cmdBuf, groupsX, groupsY, groupsZ);
1776}
1777
1778static inline void nvnCommandBufferDispatchComputeIndirect(NVNcommandBuffer* cmdBuf,
1779 NVNbufferAddress buffer) {
1780 pfnc_nvnCommandBufferDispatchComputeIndirect(cmdBuf, buffer);
1781}
1782
1783static inline void nvnCommandBufferSetViewport(NVNcommandBuffer* cmdBuf, int x, int y, int w,
1784 int h) {
1785 pfnc_nvnCommandBufferSetViewport(cmdBuf, x, y, w, h);
1786}
1787
1788static inline void nvnCommandBufferSetViewports(NVNcommandBuffer* cmdBuf, int first, int count,
1789 const float* ranges) {
1790 pfnc_nvnCommandBufferSetViewports(cmdBuf, first, count, ranges);
1791}
1792
1793static inline void nvnCommandBufferSetViewportSwizzles(NVNcommandBuffer* cmdBuf, int first,
1794 int count,
1795 const NVNviewportSwizzle* swizzles) {
1796 pfnc_nvnCommandBufferSetViewportSwizzles(cmdBuf, first, count, swizzles);
1797}
1798
1799static inline void nvnCommandBufferSetScissor(NVNcommandBuffer* cmdBuf, int x, int y, int w,
1800 int h) {
1801 pfnc_nvnCommandBufferSetScissor(cmdBuf, x, y, w, h);
1802}
1803
1804static inline void nvnCommandBufferSetScissors(NVNcommandBuffer* cmdBuf, int first, int count,
1805 const int* rects) {
1806 pfnc_nvnCommandBufferSetScissors(cmdBuf, first, count, rects);
1807}
1808
1809static inline void nvnCommandBufferSetDepthRange(NVNcommandBuffer* cmdBuf, float n, float f) {
1810 pfnc_nvnCommandBufferSetDepthRange(cmdBuf, n, f);
1811}
1812
1813static inline void nvnCommandBufferSetDepthBounds(NVNcommandBuffer* cmdBuf, NVNboolean enable,
1814 float n, float f) {
1815 pfnc_nvnCommandBufferSetDepthBounds(cmdBuf, enable, n, f);
1816}
1817
1818static inline void nvnCommandBufferSetDepthRanges(NVNcommandBuffer* cmdBuf, int first, int count,
1819 const float* ranges) {
1820 pfnc_nvnCommandBufferSetDepthRanges(cmdBuf, first, count, ranges);
1821}
1822
1823static inline void nvnCommandBufferSetTiledCacheAction(NVNcommandBuffer* cmdBuf,
1824 NVNtiledCacheAction action) {
1825 pfnc_nvnCommandBufferSetTiledCacheAction(cmdBuf, action);
1826}
1827
1828static inline void nvnCommandBufferSetTiledCacheTileSize(NVNcommandBuffer* cmdBuf, int w, int h) {
1829 pfnc_nvnCommandBufferSetTiledCacheTileSize(cmdBuf, w, h);
1830}
1831
1832static inline void nvnCommandBufferBindSeparateTexture(NVNcommandBuffer* cmdBuf,
1833 NVNshaderStage stage, int i,
1834 NVNseparateTextureHandle handle) {
1835 pfnc_nvnCommandBufferBindSeparateTexture(cmdBuf, stage, i, handle);
1836}
1837
1838static inline void nvnCommandBufferBindSeparateSampler(NVNcommandBuffer* cmdBuf,
1839 NVNshaderStage stage, int i,
1840 NVNseparateSamplerHandle handle) {
1841 pfnc_nvnCommandBufferBindSeparateSampler(cmdBuf, stage, i, handle);
1842}
1843
1844static inline void nvnCommandBufferBindSeparateTextures(NVNcommandBuffer* cmdBuf,
1845 NVNshaderStage stage, int i1, int i2,
1846 const NVNseparateTextureHandle* handle) {
1847 pfnc_nvnCommandBufferBindSeparateTextures(cmdBuf, stage, i1, i2, handle);
1848}
1849
1850static inline void nvnCommandBufferBindSeparateSamplers(NVNcommandBuffer* cmdBuf,
1851 NVNshaderStage stage, int i1, int i2,
1852 const NVNseparateSamplerHandle* handle) {
1853 pfnc_nvnCommandBufferBindSeparateSamplers(cmdBuf, stage, i1, i2, handle);
1854}
1855
1856static inline void nvnCommandBufferSetStencilValueMask(NVNcommandBuffer* cmdBuf, NVNface faces,
1857 int mask) {
1858 pfnc_nvnCommandBufferSetStencilValueMask(cmdBuf, faces, mask);
1859}
1860
1861static inline void nvnCommandBufferSetStencilMask(NVNcommandBuffer* cmdBuf, NVNface faces,
1862 int mask) {
1863 pfnc_nvnCommandBufferSetStencilMask(cmdBuf, faces, mask);
1864}
1865
1866static inline void nvnCommandBufferSetStencilRef(NVNcommandBuffer* cmdBuf, NVNface faces, int ref) {
1867 pfnc_nvnCommandBufferSetStencilRef(cmdBuf, faces, ref);
1868}
1869
1870static inline void nvnCommandBufferSetBlendColor(NVNcommandBuffer* cmdBuf,
1871 const float* blendColor) {
1872 pfnc_nvnCommandBufferSetBlendColor(cmdBuf, blendColor);
1873}
1874
1875static inline void nvnCommandBufferSetPointSize(NVNcommandBuffer* cmdBuf, float pointSize) {
1876 pfnc_nvnCommandBufferSetPointSize(cmdBuf, pointSize);
1877}
1878
1879static inline void nvnCommandBufferSetLineWidth(NVNcommandBuffer* cmdBuf, float lineWidth) {
1880 pfnc_nvnCommandBufferSetLineWidth(cmdBuf, lineWidth);
1881}
1882
1883static inline void nvnCommandBufferSetPolygonOffsetClamp(NVNcommandBuffer* cmdBuf, float factor,
1884 float units, float clamp) {
1885 pfnc_nvnCommandBufferSetPolygonOffsetClamp(cmdBuf, factor, units, clamp);
1886}
1887
1888static inline void nvnCommandBufferSetAlphaRef(NVNcommandBuffer* cmdBuf, float ref) {
1889 pfnc_nvnCommandBufferSetAlphaRef(cmdBuf, ref);
1890}
1891
1892static inline void nvnCommandBufferSetSampleMask(NVNcommandBuffer* cmdBuf, int mask) {
1893 pfnc_nvnCommandBufferSetSampleMask(cmdBuf, mask);
1894}
1895
1896static inline void nvnCommandBufferSetRasterizerDiscard(NVNcommandBuffer* cmdBuf,
1897 NVNboolean discard) {
1898 pfnc_nvnCommandBufferSetRasterizerDiscard(cmdBuf, discard);
1899}
1900
1901static inline void nvnCommandBufferSetDepthClamp(NVNcommandBuffer* cmdBuf, NVNboolean clamp) {
1902 pfnc_nvnCommandBufferSetDepthClamp(cmdBuf, clamp);
1903}
1904
1905static inline void nvnCommandBufferSetConservativeRasterEnable(NVNcommandBuffer* cmdBuf,
1906 NVNboolean enable) {
1907 pfnc_nvnCommandBufferSetConservativeRasterEnable(cmdBuf, enable);
1908}
1909
1910static inline void nvnCommandBufferSetConservativeRasterDilate(NVNcommandBuffer* cmdBuf, float f) {
1911 pfnc_nvnCommandBufferSetConservativeRasterDilate(cmdBuf, f);
1912}
1913
1914static inline void nvnCommandBufferSetSubpixelPrecisionBias(NVNcommandBuffer* cmdBuf, int i1,
1915 int i2) {
1916 pfnc_nvnCommandBufferSetSubpixelPrecisionBias(cmdBuf, i1, i2);
1917}
1918
1919static inline void nvnCommandBufferCopyBufferToTexture(NVNcommandBuffer* cmdBuf,
1920 NVNbufferAddress buffer,
1921 const NVNtexture* dstTexture,
1922 const NVNtextureView* dstView,
1923 const NVNcopyRegion* dstRegion, int flags) {
1924 pfnc_nvnCommandBufferCopyBufferToTexture(cmdBuf, buffer, dstTexture, dstView, dstRegion, flags);
1925}
1926
1927static inline void nvnCommandBufferCopyTextureToBuffer(NVNcommandBuffer* cmdBuf,
1928 const NVNtexture* srcTexture,
1929 const NVNtextureView* srcView,
1930 const NVNcopyRegion* srcRegion,
1931 NVNbufferAddress buffer, int flags) {
1932 pfnc_nvnCommandBufferCopyTextureToBuffer(cmdBuf, srcTexture, srcView, srcRegion, buffer, flags);
1933}
1934
1935static inline void
1936nvnCommandBufferCopyTextureToTexture(NVNcommandBuffer* cmdBuf, const NVNtexture* srcTexture,
1937 const NVNtextureView* srcView, const NVNcopyRegion* srcRegion,
1938 const NVNtexture* dstTexture, const NVNtextureView* dstView,
1939 const NVNcopyRegion* dstRegion, int flags) {
1940 pfnc_nvnCommandBufferCopyTextureToTexture(cmdBuf, srcTexture, srcView, srcRegion, dstTexture,
1941 dstView, dstRegion, flags);
1942}
1943
1944static inline void nvnCommandBufferCopyBufferToBuffer(NVNcommandBuffer* cmdBuf,
1945 NVNbufferAddress src, NVNbufferAddress dst,
1946 size_t size, int flags) {
1947 pfnc_nvnCommandBufferCopyBufferToBuffer(cmdBuf, src, dst, size, flags);
1948}
1949
1950static inline void nvnCommandBufferClearBuffer(NVNcommandBuffer* cmdBuf, NVNbufferAddress buffer,
1951 size_t size, uint32_t i) {
1952 pfnc_nvnCommandBufferClearBuffer(cmdBuf, buffer, size, i);
1953}
1954
1955static inline void nvnCommandBufferClearTexture(NVNcommandBuffer* cmdBuf,
1956 const NVNtexture* dstTexture,
1957 const NVNtextureView* dstView,
1958 const NVNcopyRegion* dstRegion, const float* color,
1959 int mask) {
1960 pfnc_nvnCommandBufferClearTexture(cmdBuf, dstTexture, dstView, dstRegion, color, mask);
1961}
1962
1963static inline void nvnCommandBufferClearTexturei(NVNcommandBuffer* cmdBuf,
1964 const NVNtexture* dstTexture,
1965 const NVNtextureView* dstView,
1966 const NVNcopyRegion* dstRegion, const int* color,
1967 int mask) {
1968 pfnc_nvnCommandBufferClearTexturei(cmdBuf, dstTexture, dstView, dstRegion, color, mask);
1969}
1970
1971static inline void nvnCommandBufferClearTextureui(NVNcommandBuffer* cmdBuf,
1972 const NVNtexture* dstTexture,
1973 const NVNtextureView* dstView,
1974 const NVNcopyRegion* dstRegion,
1975 const uint32_t* color, int mask) {
1976 pfnc_nvnCommandBufferClearTextureui(cmdBuf, dstTexture, dstView, dstRegion, color, mask);
1977}
1978
1979static inline void nvnCommandBufferUpdateUniformBuffer(NVNcommandBuffer* cmdBuf,
1980 NVNbufferAddress buffer, size_t size,
1981 ptrdiff_t o, size_t s, const void* p) {
1982 pfnc_nvnCommandBufferUpdateUniformBuffer(cmdBuf, buffer, size, o, s, p);
1983}
1984
1985static inline void nvnCommandBufferReportCounter(NVNcommandBuffer* cmdBuf, NVNcounterType counter,
1986 NVNbufferAddress buffer) {
1987 pfnc_nvnCommandBufferReportCounter(cmdBuf, counter, buffer);
1988}
1989
1990static inline void nvnCommandBufferResetCounter(NVNcommandBuffer* cmdBuf, NVNcounterType counter) {
1991 pfnc_nvnCommandBufferResetCounter(cmdBuf, counter);
1992}
1993
1994static inline void nvnCommandBufferReportValue(NVNcommandBuffer* cmdBuf, uint32_t value,
1995 NVNbufferAddress buffer) {
1996 pfnc_nvnCommandBufferReportValue(cmdBuf, value, buffer);
1997}
1998
1999static inline void nvnCommandBufferSetRenderEnable(NVNcommandBuffer* cmdBuf, NVNboolean enable) {
2000 pfnc_nvnCommandBufferSetRenderEnable(cmdBuf, enable);
2001}
2002
2003static inline void nvnCommandBufferSetRenderEnableConditional(NVNcommandBuffer* cmdBuf,
2004 NVNconditionalRenderMode mode,
2005 NVNbufferAddress addr) {
2006 pfnc_nvnCommandBufferSetRenderEnableConditional(cmdBuf, mode, addr);
2007}
2008
2009static inline void nvnCommandBufferSetRenderTargets(NVNcommandBuffer* cmdBuf, int numColors,
2010 const NVNtexture* const* colors,
2011 const NVNtextureView* const* colorViews,
2012 const NVNtexture* depthStencil,
2013 const NVNtextureView* depthStencilView) {
2014 pfnc_nvnCommandBufferSetRenderTargets(cmdBuf, numColors, colors, colorViews, depthStencil,
2015 depthStencilView);
2016}
2017
2018static inline void nvnCommandBufferDiscardColor(NVNcommandBuffer* cmdBuf, int i) {
2019 pfnc_nvnCommandBufferDiscardColor(cmdBuf, i);
2020}
2021
2022static inline void nvnCommandBufferDiscardDepthStencil(NVNcommandBuffer* cmdBuf) {
2023 pfnc_nvnCommandBufferDiscardDepthStencil(cmdBuf);
2024}
2025
2026static inline void nvnCommandBufferDownsample(NVNcommandBuffer* cmdBuf, const NVNtexture* src,
2027 const NVNtexture* dst) {
2028 pfnc_nvnCommandBufferDownsample(cmdBuf, src, dst);
2029}
2030
2031static inline void nvnCommandBufferTiledDownsample(NVNcommandBuffer* cmdBuf,
2032 const NVNtexture* texture1,
2033 const NVNtexture* texture2) {
2034 pfnc_nvnCommandBufferTiledDownsample(cmdBuf, texture1, texture2);
2035}
2036
2037static inline void nvnCommandBufferDownsampleTextureView(NVNcommandBuffer* cmdBuf,
2038 const NVNtexture* texture1,
2039 const NVNtextureView* view1,
2040 const NVNtexture* texture2,
2041 const NVNtextureView* view2) {
2042 pfnc_nvnCommandBufferDownsampleTextureView(cmdBuf, texture1, view1, texture2, view2);
2043}
2044
2045static inline void nvnCommandBufferTiledDownsampleTextureView(NVNcommandBuffer* cmdBuf,
2046 const NVNtexture* texture1,
2047 const NVNtextureView* view1,
2048 const NVNtexture* texture2,
2049 const NVNtextureView* view2) {
2050 pfnc_nvnCommandBufferTiledDownsampleTextureView(cmdBuf, texture1, view1, texture2, view2);
2051}
2052
2053static inline void nvnCommandBufferBarrier(NVNcommandBuffer* cmdBuf, int barrier) {
2054 pfnc_nvnCommandBufferBarrier(cmdBuf, barrier);
2055}
2056
2057static inline void nvnCommandBufferWaitSync(NVNcommandBuffer* cmdBuf, const NVNsync* sync) {
2058 pfnc_nvnCommandBufferWaitSync(cmdBuf, sync);
2059}
2060
2061static inline void nvnCommandBufferFenceSync(NVNcommandBuffer* cmdBuf, NVNsync* sync,
2062 NVNsyncCondition condition, int fence) {
2063 pfnc_nvnCommandBufferFenceSync(cmdBuf, sync, condition, fence);
2064}
2065
2066static inline void nvnCommandBufferSetTexturePool(NVNcommandBuffer* cmdBuf,
2067 const NVNtexturePool* pool) {
2068 pfnc_nvnCommandBufferSetTexturePool(cmdBuf, pool);
2069}
2070
2071static inline void nvnCommandBufferSetSamplerPool(NVNcommandBuffer* cmdBuf,
2072 const NVNsamplerPool* pool) {
2073 pfnc_nvnCommandBufferSetSamplerPool(cmdBuf, pool);
2074}
2075
2076static inline void nvnCommandBufferSetShaderScratchMemory(NVNcommandBuffer* cmdBuf,
2077 const NVNmemoryPool* pool,
2078 ptrdiff_t offset, size_t size) {
2079 pfnc_nvnCommandBufferSetShaderScratchMemory(cmdBuf, pool, offset, size);
2080}
2081
2082static inline void nvnCommandBufferSaveZCullData(NVNcommandBuffer* cmdBuf, NVNbufferAddress addr,
2083 size_t size) {
2084 pfnc_nvnCommandBufferSaveZCullData(cmdBuf, addr, size);
2085}
2086
2087static inline void nvnCommandBufferRestoreZCullData(NVNcommandBuffer* cmdBuf, NVNbufferAddress addr,
2088 size_t size) {
2089 pfnc_nvnCommandBufferRestoreZCullData(cmdBuf, addr, size);
2090}
2091
2092static inline void nvnCommandBufferSetCopyRowStride(NVNcommandBuffer* cmdBuf, ptrdiff_t stride) {
2093 pfnc_nvnCommandBufferSetCopyRowStride(cmdBuf, stride);
2094}
2095
2096static inline void nvnCommandBufferSetCopyImageStride(NVNcommandBuffer* cmdBuf, ptrdiff_t stride) {
2097 pfnc_nvnCommandBufferSetCopyImageStride(cmdBuf, stride);
2098}
2099
2100static inline ptrdiff_t nvnCommandBufferGetCopyRowStride(const NVNcommandBuffer* cmdBuf) {
2101 return pfnc_nvnCommandBufferGetCopyRowStride(cmdBuf);
2102}
2103
2104static inline ptrdiff_t nvnCommandBufferGetCopyImageStride(const NVNcommandBuffer* cmdBuf) {
2105 return pfnc_nvnCommandBufferGetCopyImageStride(cmdBuf);
2106}
2107
2108static inline void nvnCommandBufferDrawTexture(NVNcommandBuffer* cmdBuf, NVNtextureHandle handle,
2109 const NVNdrawTextureRegion* region1,
2110 const NVNdrawTextureRegion* region2) {
2111 pfnc_nvnCommandBufferDrawTexture(cmdBuf, handle, region1, region2);
2112}
2113
2114static inline NVNboolean nvnProgramSetSubroutineLinkage(NVNprogram* program, int i,
2115 const NVNsubroutineLinkageMapPtr* ptr) {
2116 return pfnc_nvnProgramSetSubroutineLinkage(program, i, ptr);
2117}
2118
2119static inline void nvnCommandBufferSetProgramSubroutines(NVNcommandBuffer* cmdBuf,
2120 NVNprogram* program, NVNshaderStage stage,
2121 const int i1, const int i2,
2122 const int* i3) {
2123 pfnc_nvnCommandBufferSetProgramSubroutines(cmdBuf, program, stage, i1, i2, i3);
2124}
2125
2126static inline void nvnCommandBufferBindCoverageModulationTable(NVNcommandBuffer* cmdBuf,
2127 const float* f) {
2128 pfnc_nvnCommandBufferBindCoverageModulationTable(cmdBuf, f);
2129}
2130
2131static inline void nvnCommandBufferResolveDepthBuffer(NVNcommandBuffer* cmdBuf) {
2132 pfnc_nvnCommandBufferResolveDepthBuffer(cmdBuf);
2133}
2134
2135static inline void nvnCommandBufferPushDebugGroupStatic(NVNcommandBuffer* cmdBuf, uint32_t i,
2136 const char* description) {
2137 pfnc_nvnCommandBufferPushDebugGroupStatic(cmdBuf, i, description);
2138}
2139
2140static inline void nvnCommandBufferPushDebugGroupDynamic(NVNcommandBuffer* cmdBuf, uint32_t i,
2141 const char* description) {
2142 pfnc_nvnCommandBufferPushDebugGroupDynamic(cmdBuf, i, description);
2143}
2144
2145static inline void nvnCommandBufferPushDebugGroup(NVNcommandBuffer* cmdBuf, uint32_t i,
2146 const char* description) {
2147 pfnc_nvnCommandBufferPushDebugGroup(cmdBuf, i, description);
2148}
2149
2150static inline void nvnCommandBufferPopDebugGroup(NVNcommandBuffer* cmdBuf) {
2151 pfnc_nvnCommandBufferPopDebugGroup(cmdBuf);
2152}
2153
2154static inline void nvnCommandBufferPopDebugGroupId(NVNcommandBuffer* cmdBuf, uint32_t i) {
2155 pfnc_nvnCommandBufferPopDebugGroupId(cmdBuf, i);
2156}
2157
2158static inline void nvnCommandBufferInsertDebugMarkerStatic(NVNcommandBuffer* cmdBuf, uint32_t i,
2159 const char* description) {
2160 pfnc_nvnCommandBufferInsertDebugMarkerStatic(cmdBuf, i, description);
2161}
2162
2163static inline void nvnCommandBufferInsertDebugMarkerDynamic(NVNcommandBuffer* cmdBuf, uint32_t i,
2164 const char* description) {
2165 pfnc_nvnCommandBufferInsertDebugMarkerDynamic(cmdBuf, i, description);
2166}
2167
2168static inline void nvnCommandBufferInsertDebugMarker(NVNcommandBuffer* cmdBuf,
2169 const char* description) {
2170 pfnc_nvnCommandBufferInsertDebugMarker(cmdBuf, description);
2171}
2172
2173static inline PFNNVNCOMMANDBUFFERMEMORYCALLBACKPROC
2174nvnCommandBufferGetMemoryCallback(const NVNcommandBuffer* cmdBuf) {
2175 return pfnc_nvnCommandBufferGetMemoryCallback(cmdBuf);
2176}
2177
2178static inline void nvnCommandBufferGetMemoryCallbackData(const NVNcommandBuffer* cmdBuf) {
2179 pfnc_nvnCommandBufferGetMemoryCallbackData(cmdBuf);
2180}
2181
2182static inline NVNboolean nvnCommandBufferIsRecording(const NVNcommandBuffer* cmdBuf) {
2183 return pfnc_nvnCommandBufferIsRecording(cmdBuf);
2184}
2185
2186static inline NVNboolean nvnSyncInitialize(NVNsync* sync, NVNdevice* device) {
2187 return pfnc_nvnSyncInitialize(sync, device);
2188}
2189
2190static inline void nvnSyncFinalize(NVNsync* sync) {
2191 pfnc_nvnSyncFinalize(sync);
2192}
2193
2194static inline void nvnSyncSetDebugLabel(NVNsync* sync, const char* label) {
2195 pfnc_nvnSyncSetDebugLabel(sync, label);
2196}
2197
2198static inline void nvnQueueFenceSync(NVNqueue* queue, NVNsync* sync, NVNsyncCondition condition,
2199 int flags) {
2200 pfnc_nvnQueueFenceSync(queue, sync, condition, flags);
2201}
2202
2203static inline NVNsyncWaitResult nvnSyncWait(const NVNsync* sync, uint64_t timeoutNs) {
2204 return pfnc_nvnSyncWait(sync, timeoutNs);
2205}
2206
2207static inline NVNboolean nvnQueueWaitSync(NVNqueue* queue, const NVNsync* sync) {
2208 return pfnc_nvnQueueWaitSync(queue, sync);
2209}
2210
2211static inline void nvnEventBuilderSetDefaults(NVNeventBuilder* builder) {
2212 pfnc_nvnEventBuilderSetDefaults(builder);
2213}
2214
2215static inline void nvnEventBuilderSetStorage(NVNeventBuilder* builder, const NVNmemoryPool* pool,
2216 int64_t size) {
2217 pfnc_nvnEventBuilderSetStorage(builder, pool, size);
2218}
2219
2220static inline NVNboolean nvnEventInitialize(NVNevent* event, const NVNeventBuilder* builder) {
2221 return pfnc_nvnEventInitialize(event, builder);
2222}
2223
2224static inline void nvnEventFinalize(NVNevent* event) {
2225 pfnc_nvnEventFinalize(event);
2226}
2227
2228static inline uint32_t nvnEventGetValue(const NVNevent* event) {
2229 return pfnc_nvnEventGetValue(event);
2230}
2231
2232static inline void nvnEventSignal(NVNevent* event, NVNeventSignalMode mode, uint32_t i) {
2233 pfnc_nvnEventSignal(event, mode, i);
2234}
2235
2236static inline void nvnCommandBufferWaitEvent(NVNcommandBuffer* cmdBuf, const NVNevent* event,
2237 NVNeventWaitMode mode, uint32_t i) {
2238 pfnc_nvnCommandBufferWaitEvent(cmdBuf, event, mode, i);
2239}
2240
2241static inline void nvnCommandBufferSignalEvent(NVNcommandBuffer* cmdBuf, const NVNevent* event,
2242 NVNeventSignalMode mode,
2243 NVNeventSignalLocation location, int flags,
2244 uint32_t i) {
2245 pfnc_nvnCommandBufferSignalEvent(cmdBuf, event, mode, location, flags, i);
2246}
2247
2248#ifdef __cplusplus
2249}
2250#endif