1 module wgpu.bindings; 2 // AUTOMATICALLY GENERATED: DO NOT EDIT 3 4 5 import core.stdc.config; 6 import core.stdc.stdarg: va_list; 7 static import core.simd; 8 static import std.conv; 9 10 struct Int128 { long lower; long upper; } 11 struct UInt128 { ulong lower; ulong upper; } 12 13 struct __locale_data { int dummy; } 14 15 16 17 alias _Bool = bool; 18 struct dpp { 19 static struct Opaque(int N) { 20 void[N] bytes; 21 } 22 23 static bool isEmpty(T)() { 24 return T.tupleof.length == 0; 25 } 26 static struct Move(T) { 27 T* ptr; 28 } 29 30 31 static auto move(T)(ref T value) { 32 return Move!T(&value); 33 } 34 mixin template EnumD(string name, T, string prefix) if(is(T == enum)) { 35 private static string _memberMixinStr(string member) { 36 import std.conv: text; 37 import std.array: replace; 38 return text(` `, member.replace(prefix, ""), ` = `, T.stringof, `.`, member, `,`); 39 } 40 private static string _enumMixinStr() { 41 import std.array: join; 42 string[] ret; 43 ret ~= "enum " ~ name ~ "{"; 44 static foreach(member; __traits(allMembers, T)) { 45 ret ~= _memberMixinStr(member); 46 } 47 ret ~= "}"; 48 return ret.join("\n"); 49 } 50 mixin(_enumMixinStr()); 51 } 52 } 53 54 extern(C) 55 { 56 alias fsfilcnt_t = c_ulong; 57 alias fsblkcnt_t = c_ulong; 58 alias blkcnt_t = c_long; 59 alias blksize_t = c_long; 60 alias register_t = c_long; 61 alias u_int64_t = c_ulong; 62 alias u_int32_t = uint; 63 alias u_int16_t = ushort; 64 alias u_int8_t = ubyte; 65 alias key_t = int; 66 alias caddr_t = char*; 67 alias daddr_t = int; 68 alias ssize_t = c_long; 69 alias id_t = uint; 70 alias pid_t = int; 71 alias off_t = c_long; 72 alias uid_t = uint; 73 alias nlink_t = c_ulong; 74 alias mode_t = uint; 75 alias gid_t = uint; 76 alias dev_t = c_ulong; 77 alias ino_t = c_ulong; 78 alias loff_t = c_long; 79 alias fsid_t = __fsid_t; 80 alias u_quad_t = c_ulong; 81 alias quad_t = c_long; 82 alias u_long = c_ulong; 83 alias u_int = uint; 84 alias u_short = ushort; 85 alias u_char = ubyte; 86 c_ulong gnu_dev_makedev(uint, uint) @nogc nothrow; 87 uint gnu_dev_minor(c_ulong) @nogc nothrow; 88 uint gnu_dev_major(c_ulong) @nogc nothrow; 89 int pselect(int, fd_set*, fd_set*, fd_set*, const(timespec)*, const(__sigset_t)*) @nogc nothrow; 90 int select(int, fd_set*, fd_set*, fd_set*, timeval*) @nogc nothrow; 91 alias fd_mask = c_long; 92 struct fd_set 93 { 94 c_long[16] __fds_bits; 95 } 96 alias __fd_mask = c_long; 97 alias suseconds_t = c_long; 98 enum _Anonymous_0 99 { 100 P_ALL = 0, 101 P_PID = 1, 102 P_PGID = 2, 103 } 104 enum P_ALL = _Anonymous_0.P_ALL; 105 enum P_PID = _Anonymous_0.P_PID; 106 enum P_PGID = _Anonymous_0.P_PGID; 107 alias idtype_t = _Anonymous_0; 108 static c_ulong __uint64_identity(c_ulong) @nogc nothrow; 109 static uint __uint32_identity(uint) @nogc nothrow; 110 static ushort __uint16_identity(ushort) @nogc nothrow; 111 alias timer_t = void*; 112 alias time_t = c_long; 113 struct timeval 114 { 115 c_long tv_sec; 116 c_long tv_usec; 117 } 118 struct timespec 119 { 120 c_long tv_sec; 121 c_long tv_nsec; 122 } 123 alias sigset_t = __sigset_t; 124 alias clockid_t = int; 125 alias clock_t = c_long; 126 struct __sigset_t 127 { 128 c_ulong[16] __val; 129 } 130 alias __sig_atomic_t = int; 131 alias __socklen_t = uint; 132 alias __intptr_t = c_long; 133 alias __caddr_t = char*; 134 alias __loff_t = c_long; 135 alias __syscall_ulong_t = c_ulong; 136 alias __syscall_slong_t = c_long; 137 alias __ssize_t = c_long; 138 alias __fsword_t = c_long; 139 alias __fsfilcnt64_t = c_ulong; 140 alias __fsfilcnt_t = c_ulong; 141 alias __fsblkcnt64_t = c_ulong; 142 alias __fsblkcnt_t = c_ulong; 143 alias __blkcnt64_t = c_long; 144 alias __blkcnt_t = c_long; 145 alias __blksize_t = c_long; 146 alias __timer_t = void*; 147 alias __clockid_t = int; 148 alias __key_t = int; 149 alias __daddr_t = int; 150 alias __suseconds_t = c_long; 151 alias __useconds_t = uint; 152 alias __time_t = c_long; 153 alias __id_t = uint; 154 alias __rlim64_t = c_ulong; 155 alias __rlim_t = c_ulong; 156 alias __clock_t = c_long; 157 struct __fsid_t 158 { 159 int[2] __val; 160 } 161 alias __pid_t = int; 162 alias __off64_t = c_long; 163 alias __off_t = c_long; 164 alias __nlink_t = c_ulong; 165 alias __mode_t = uint; 166 alias __ino64_t = c_ulong; 167 alias __ino_t = c_ulong; 168 alias __gid_t = uint; 169 alias __uid_t = uint; 170 alias __dev_t = c_ulong; 171 alias __uintmax_t = c_ulong; 172 alias __intmax_t = c_long; 173 alias __u_quad_t = c_ulong; 174 alias __quad_t = c_long; 175 alias __uint64_t = c_ulong; 176 alias __int64_t = c_long; 177 alias __uint32_t = uint; 178 alias __int32_t = int; 179 alias __uint16_t = ushort; 180 alias __int16_t = short; 181 alias __uint8_t = ubyte; 182 alias __int8_t = byte; 183 alias __u_long = c_ulong; 184 alias __u_int = uint; 185 alias __u_short = ushort; 186 alias __u_char = ubyte; 187 struct __pthread_cond_s 188 { 189 static union _Anonymous_1 190 { 191 ulong __wseq; 192 static struct _Anonymous_2 193 { 194 uint __low; 195 uint __high; 196 } 197 _Anonymous_2 __wseq32; 198 } 199 _Anonymous_1 _anonymous_3; 200 auto __wseq() @property @nogc pure nothrow { return _anonymous_3.__wseq; } 201 void __wseq(_T_)(auto ref _T_ val) @property @nogc pure nothrow { _anonymous_3.__wseq = val; } 202 auto __wseq32() @property @nogc pure nothrow { return _anonymous_3.__wseq32; } 203 void __wseq32(_T_)(auto ref _T_ val) @property @nogc pure nothrow { _anonymous_3.__wseq32 = val; } 204 static union _Anonymous_4 205 { 206 ulong __g1_start; 207 static struct _Anonymous_5 208 { 209 uint __low; 210 uint __high; 211 } 212 _Anonymous_5 __g1_start32; 213 } 214 _Anonymous_4 _anonymous_6; 215 auto __g1_start() @property @nogc pure nothrow { return _anonymous_6.__g1_start; } 216 void __g1_start(_T_)(auto ref _T_ val) @property @nogc pure nothrow { _anonymous_6.__g1_start = val; } 217 auto __g1_start32() @property @nogc pure nothrow { return _anonymous_6.__g1_start32; } 218 void __g1_start32(_T_)(auto ref _T_ val) @property @nogc pure nothrow { _anonymous_6.__g1_start32 = val; } 219 uint[2] __g_refs; 220 uint[2] __g_size; 221 uint __g1_orig_size; 222 uint __wrefs; 223 uint[2] __g_signals; 224 } 225 alias WGPUNonZeroU64 = ulong; 226 alias WGPUOption_NonZeroU32 = c_ulong; 227 alias WGPUOption_NonZeroU64 = c_ulong; 228 alias WGPUOption_AdapterId = ulong; 229 alias WGPUOption_BufferId = ulong; 230 alias WGPUOption_SamplerId = ulong; 231 alias WGPUOption_SurfaceId = ulong; 232 alias WGPUOption_TextureViewId = ulong; 233 struct WGPUChainedStruct 234 { 235 const(WGPUChainedStruct)* next; 236 uint s_type; 237 } 238 struct __pthread_mutex_s 239 { 240 int __lock; 241 uint __count; 242 int __owner; 243 uint __nusers; 244 int __kind; 245 short __spins; 246 short __elision; 247 __pthread_internal_list __list; 248 } 249 struct __pthread_internal_list 250 { 251 __pthread_internal_list* __prev; 252 __pthread_internal_list* __next; 253 } 254 alias __pthread_list_t = __pthread_internal_list; 255 enum WGPUAddressMode 256 { 257 WGPUAddressMode_ClampToEdge = 0, 258 WGPUAddressMode_Repeat = 1, 259 WGPUAddressMode_MirrorRepeat = 2, 260 } 261 enum WGPUAddressMode_ClampToEdge = WGPUAddressMode.WGPUAddressMode_ClampToEdge; 262 enum WGPUAddressMode_Repeat = WGPUAddressMode.WGPUAddressMode_Repeat; 263 enum WGPUAddressMode_MirrorRepeat = WGPUAddressMode.WGPUAddressMode_MirrorRepeat; 264 enum WGPUBackend 265 { 266 WGPUBackend_Empty = 0, 267 WGPUBackend_Vulkan = 1, 268 WGPUBackend_Metal = 2, 269 WGPUBackend_Dx12 = 3, 270 WGPUBackend_Dx11 = 4, 271 WGPUBackend_Gl = 5, 272 WGPUBackend_BrowserWebGpu = 6, 273 } 274 enum WGPUBackend_Empty = WGPUBackend.WGPUBackend_Empty; 275 enum WGPUBackend_Vulkan = WGPUBackend.WGPUBackend_Vulkan; 276 enum WGPUBackend_Metal = WGPUBackend.WGPUBackend_Metal; 277 enum WGPUBackend_Dx12 = WGPUBackend.WGPUBackend_Dx12; 278 enum WGPUBackend_Dx11 = WGPUBackend.WGPUBackend_Dx11; 279 enum WGPUBackend_Gl = WGPUBackend.WGPUBackend_Gl; 280 enum WGPUBackend_BrowserWebGpu = WGPUBackend.WGPUBackend_BrowserWebGpu; 281 alias WGPUBackend_ = ubyte; 282 enum WGPUBindingType 283 { 284 WGPUBindingType_UniformBuffer = 0, 285 WGPUBindingType_StorageBuffer = 1, 286 WGPUBindingType_ReadonlyStorageBuffer = 2, 287 WGPUBindingType_Sampler = 3, 288 WGPUBindingType_ComparisonSampler = 4, 289 WGPUBindingType_SampledTexture = 5, 290 WGPUBindingType_ReadonlyStorageTexture = 6, 291 WGPUBindingType_WriteonlyStorageTexture = 7, 292 } 293 enum WGPUBindingType_UniformBuffer = WGPUBindingType.WGPUBindingType_UniformBuffer; 294 enum WGPUBindingType_StorageBuffer = WGPUBindingType.WGPUBindingType_StorageBuffer; 295 enum WGPUBindingType_ReadonlyStorageBuffer = WGPUBindingType.WGPUBindingType_ReadonlyStorageBuffer; 296 enum WGPUBindingType_Sampler = WGPUBindingType.WGPUBindingType_Sampler; 297 enum WGPUBindingType_ComparisonSampler = WGPUBindingType.WGPUBindingType_ComparisonSampler; 298 enum WGPUBindingType_SampledTexture = WGPUBindingType.WGPUBindingType_SampledTexture; 299 enum WGPUBindingType_ReadonlyStorageTexture = WGPUBindingType.WGPUBindingType_ReadonlyStorageTexture; 300 enum WGPUBindingType_WriteonlyStorageTexture = WGPUBindingType.WGPUBindingType_WriteonlyStorageTexture; 301 alias WGPUBindingType_ = uint; 302 enum WGPUBlendFactor 303 { 304 WGPUBlendFactor_Zero = 0, 305 WGPUBlendFactor_One = 1, 306 WGPUBlendFactor_SrcColor = 2, 307 WGPUBlendFactor_OneMinusSrcColor = 3, 308 WGPUBlendFactor_SrcAlpha = 4, 309 WGPUBlendFactor_OneMinusSrcAlpha = 5, 310 WGPUBlendFactor_DstColor = 6, 311 WGPUBlendFactor_OneMinusDstColor = 7, 312 WGPUBlendFactor_DstAlpha = 8, 313 WGPUBlendFactor_OneMinusDstAlpha = 9, 314 WGPUBlendFactor_SrcAlphaSaturated = 10, 315 WGPUBlendFactor_BlendColor = 11, 316 WGPUBlendFactor_OneMinusBlendColor = 12, 317 } 318 enum WGPUBlendFactor_Zero = WGPUBlendFactor.WGPUBlendFactor_Zero; 319 enum WGPUBlendFactor_One = WGPUBlendFactor.WGPUBlendFactor_One; 320 enum WGPUBlendFactor_SrcColor = WGPUBlendFactor.WGPUBlendFactor_SrcColor; 321 enum WGPUBlendFactor_OneMinusSrcColor = WGPUBlendFactor.WGPUBlendFactor_OneMinusSrcColor; 322 enum WGPUBlendFactor_SrcAlpha = WGPUBlendFactor.WGPUBlendFactor_SrcAlpha; 323 enum WGPUBlendFactor_OneMinusSrcAlpha = WGPUBlendFactor.WGPUBlendFactor_OneMinusSrcAlpha; 324 enum WGPUBlendFactor_DstColor = WGPUBlendFactor.WGPUBlendFactor_DstColor; 325 enum WGPUBlendFactor_OneMinusDstColor = WGPUBlendFactor.WGPUBlendFactor_OneMinusDstColor; 326 enum WGPUBlendFactor_DstAlpha = WGPUBlendFactor.WGPUBlendFactor_DstAlpha; 327 enum WGPUBlendFactor_OneMinusDstAlpha = WGPUBlendFactor.WGPUBlendFactor_OneMinusDstAlpha; 328 enum WGPUBlendFactor_SrcAlphaSaturated = WGPUBlendFactor.WGPUBlendFactor_SrcAlphaSaturated; 329 enum WGPUBlendFactor_BlendColor = WGPUBlendFactor.WGPUBlendFactor_BlendColor; 330 enum WGPUBlendFactor_OneMinusBlendColor = WGPUBlendFactor.WGPUBlendFactor_OneMinusBlendColor; 331 enum WGPUBlendOperation 332 { 333 WGPUBlendOperation_Add = 0, 334 WGPUBlendOperation_Subtract = 1, 335 WGPUBlendOperation_ReverseSubtract = 2, 336 WGPUBlendOperation_Min = 3, 337 WGPUBlendOperation_Max = 4, 338 } 339 enum WGPUBlendOperation_Add = WGPUBlendOperation.WGPUBlendOperation_Add; 340 enum WGPUBlendOperation_Subtract = WGPUBlendOperation.WGPUBlendOperation_Subtract; 341 enum WGPUBlendOperation_ReverseSubtract = WGPUBlendOperation.WGPUBlendOperation_ReverseSubtract; 342 enum WGPUBlendOperation_Min = WGPUBlendOperation.WGPUBlendOperation_Min; 343 enum WGPUBlendOperation_Max = WGPUBlendOperation.WGPUBlendOperation_Max; 344 enum WGPUBufferMapAsyncStatus 345 { 346 WGPUBufferMapAsyncStatus_Success = 0, 347 WGPUBufferMapAsyncStatus_Error = 1, 348 WGPUBufferMapAsyncStatus_Unknown = 2, 349 WGPUBufferMapAsyncStatus_ContextLost = 3, 350 } 351 enum WGPUBufferMapAsyncStatus_Success = WGPUBufferMapAsyncStatus.WGPUBufferMapAsyncStatus_Success; 352 enum WGPUBufferMapAsyncStatus_Error = WGPUBufferMapAsyncStatus.WGPUBufferMapAsyncStatus_Error; 353 enum WGPUBufferMapAsyncStatus_Unknown = WGPUBufferMapAsyncStatus.WGPUBufferMapAsyncStatus_Unknown; 354 enum WGPUBufferMapAsyncStatus_ContextLost = WGPUBufferMapAsyncStatus.WGPUBufferMapAsyncStatus_ContextLost; 355 enum WGPUCDeviceType 356 { 357 WGPUCDeviceType_Other = 0, 358 WGPUCDeviceType_IntegratedGpu = 1, 359 WGPUCDeviceType_DiscreteGpu = 2, 360 WGPUCDeviceType_VirtualGpu = 3, 361 WGPUCDeviceType_Cpu = 4, 362 } 363 enum WGPUCDeviceType_Other = WGPUCDeviceType.WGPUCDeviceType_Other; 364 enum WGPUCDeviceType_IntegratedGpu = WGPUCDeviceType.WGPUCDeviceType_IntegratedGpu; 365 enum WGPUCDeviceType_DiscreteGpu = WGPUCDeviceType.WGPUCDeviceType_DiscreteGpu; 366 enum WGPUCDeviceType_VirtualGpu = WGPUCDeviceType.WGPUCDeviceType_VirtualGpu; 367 enum WGPUCDeviceType_Cpu = WGPUCDeviceType.WGPUCDeviceType_Cpu; 368 alias WGPUCDeviceType_ = ubyte; 369 enum WGPUCompareFunction 370 { 371 WGPUCompareFunction_Undefined = 0, 372 WGPUCompareFunction_Never = 1, 373 WGPUCompareFunction_Less = 2, 374 WGPUCompareFunction_Equal = 3, 375 WGPUCompareFunction_LessEqual = 4, 376 WGPUCompareFunction_Greater = 5, 377 WGPUCompareFunction_NotEqual = 6, 378 WGPUCompareFunction_GreaterEqual = 7, 379 WGPUCompareFunction_Always = 8, 380 } 381 enum WGPUCompareFunction_Undefined = WGPUCompareFunction.WGPUCompareFunction_Undefined; 382 enum WGPUCompareFunction_Never = WGPUCompareFunction.WGPUCompareFunction_Never; 383 enum WGPUCompareFunction_Less = WGPUCompareFunction.WGPUCompareFunction_Less; 384 enum WGPUCompareFunction_Equal = WGPUCompareFunction.WGPUCompareFunction_Equal; 385 enum WGPUCompareFunction_LessEqual = WGPUCompareFunction.WGPUCompareFunction_LessEqual; 386 enum WGPUCompareFunction_Greater = WGPUCompareFunction.WGPUCompareFunction_Greater; 387 enum WGPUCompareFunction_NotEqual = WGPUCompareFunction.WGPUCompareFunction_NotEqual; 388 enum WGPUCompareFunction_GreaterEqual = WGPUCompareFunction.WGPUCompareFunction_GreaterEqual; 389 enum WGPUCompareFunction_Always = WGPUCompareFunction.WGPUCompareFunction_Always; 390 enum WGPUCullMode 391 { 392 WGPUCullMode_None = 0, 393 WGPUCullMode_Front = 1, 394 WGPUCullMode_Back = 2, 395 } 396 enum WGPUCullMode_None = WGPUCullMode.WGPUCullMode_None; 397 enum WGPUCullMode_Front = WGPUCullMode.WGPUCullMode_Front; 398 enum WGPUCullMode_Back = WGPUCullMode.WGPUCullMode_Back; 399 enum WGPUFilterMode 400 { 401 WGPUFilterMode_Nearest = 0, 402 WGPUFilterMode_Linear = 1, 403 } 404 enum WGPUFilterMode_Nearest = WGPUFilterMode.WGPUFilterMode_Nearest; 405 enum WGPUFilterMode_Linear = WGPUFilterMode.WGPUFilterMode_Linear; 406 enum WGPUFrontFace 407 { 408 WGPUFrontFace_Ccw = 0, 409 WGPUFrontFace_Cw = 1, 410 } 411 enum WGPUFrontFace_Ccw = WGPUFrontFace.WGPUFrontFace_Ccw; 412 enum WGPUFrontFace_Cw = WGPUFrontFace.WGPUFrontFace_Cw; 413 enum WGPUIndexFormat 414 { 415 WGPUIndexFormat_Uint16 = 0, 416 WGPUIndexFormat_Uint32 = 1, 417 } 418 enum WGPUIndexFormat_Uint16 = WGPUIndexFormat.WGPUIndexFormat_Uint16; 419 enum WGPUIndexFormat_Uint32 = WGPUIndexFormat.WGPUIndexFormat_Uint32; 420 enum WGPUInputStepMode 421 { 422 WGPUInputStepMode_Vertex = 0, 423 WGPUInputStepMode_Instance = 1, 424 } 425 enum WGPUInputStepMode_Vertex = WGPUInputStepMode.WGPUInputStepMode_Vertex; 426 enum WGPUInputStepMode_Instance = WGPUInputStepMode.WGPUInputStepMode_Instance; 427 enum WGPULoadOp 428 { 429 WGPULoadOp_Clear = 0, 430 WGPULoadOp_Load = 1, 431 } 432 enum WGPULoadOp_Clear = WGPULoadOp.WGPULoadOp_Clear; 433 enum WGPULoadOp_Load = WGPULoadOp.WGPULoadOp_Load; 434 enum WGPULogLevel 435 { 436 WGPULogLevel_Off = 0, 437 WGPULogLevel_Error = 1, 438 WGPULogLevel_Warn = 2, 439 WGPULogLevel_Info = 3, 440 WGPULogLevel_Debug = 4, 441 WGPULogLevel_Trace = 5, 442 } 443 enum WGPULogLevel_Off = WGPULogLevel.WGPULogLevel_Off; 444 enum WGPULogLevel_Error = WGPULogLevel.WGPULogLevel_Error; 445 enum WGPULogLevel_Warn = WGPULogLevel.WGPULogLevel_Warn; 446 enum WGPULogLevel_Info = WGPULogLevel.WGPULogLevel_Info; 447 enum WGPULogLevel_Debug = WGPULogLevel.WGPULogLevel_Debug; 448 enum WGPULogLevel_Trace = WGPULogLevel.WGPULogLevel_Trace; 449 enum WGPUPowerPreference 450 { 451 WGPUPowerPreference_Default = 0, 452 WGPUPowerPreference_LowPower = 1, 453 WGPUPowerPreference_HighPerformance = 2, 454 } 455 enum WGPUPowerPreference_Default = WGPUPowerPreference.WGPUPowerPreference_Default; 456 enum WGPUPowerPreference_LowPower = WGPUPowerPreference.WGPUPowerPreference_LowPower; 457 enum WGPUPowerPreference_HighPerformance = WGPUPowerPreference.WGPUPowerPreference_HighPerformance; 458 enum WGPUPresentMode 459 { 460 WGPUPresentMode_Immediate = 0, 461 WGPUPresentMode_Mailbox = 1, 462 WGPUPresentMode_Fifo = 2, 463 } 464 enum WGPUPresentMode_Immediate = WGPUPresentMode.WGPUPresentMode_Immediate; 465 enum WGPUPresentMode_Mailbox = WGPUPresentMode.WGPUPresentMode_Mailbox; 466 enum WGPUPresentMode_Fifo = WGPUPresentMode.WGPUPresentMode_Fifo; 467 enum WGPUPrimitiveTopology 468 { 469 WGPUPrimitiveTopology_PointList = 0, 470 WGPUPrimitiveTopology_LineList = 1, 471 WGPUPrimitiveTopology_LineStrip = 2, 472 WGPUPrimitiveTopology_TriangleList = 3, 473 WGPUPrimitiveTopology_TriangleStrip = 4, 474 } 475 enum WGPUPrimitiveTopology_PointList = WGPUPrimitiveTopology.WGPUPrimitiveTopology_PointList; 476 enum WGPUPrimitiveTopology_LineList = WGPUPrimitiveTopology.WGPUPrimitiveTopology_LineList; 477 enum WGPUPrimitiveTopology_LineStrip = WGPUPrimitiveTopology.WGPUPrimitiveTopology_LineStrip; 478 enum WGPUPrimitiveTopology_TriangleList = WGPUPrimitiveTopology.WGPUPrimitiveTopology_TriangleList; 479 enum WGPUPrimitiveTopology_TriangleStrip = WGPUPrimitiveTopology.WGPUPrimitiveTopology_TriangleStrip; 480 enum WGPUSType 481 { 482 WGPUSType_Invalid = 0, 483 WGPUSType_SurfaceDescriptorFromMetalLayer = 1, 484 WGPUSType_SurfaceDescriptorFromWindowsHWND = 2, 485 WGPUSType_SurfaceDescriptorFromXlib = 3, 486 WGPUSType_SurfaceDescriptorFromHTMLCanvasId = 4, 487 WGPUSType_ShaderModuleSPIRVDescriptor = 5, 488 WGPUSType_ShaderModuleWGSLDescriptor = 6, 489 WGPUSType_AnisotropicFiltering = 268435456, 490 WGPUSType_Force32 = 2147483647, 491 } 492 enum WGPUSType_Invalid = WGPUSType.WGPUSType_Invalid; 493 enum WGPUSType_SurfaceDescriptorFromMetalLayer = WGPUSType.WGPUSType_SurfaceDescriptorFromMetalLayer; 494 enum WGPUSType_SurfaceDescriptorFromWindowsHWND = WGPUSType.WGPUSType_SurfaceDescriptorFromWindowsHWND; 495 enum WGPUSType_SurfaceDescriptorFromXlib = WGPUSType.WGPUSType_SurfaceDescriptorFromXlib; 496 enum WGPUSType_SurfaceDescriptorFromHTMLCanvasId = WGPUSType.WGPUSType_SurfaceDescriptorFromHTMLCanvasId; 497 enum WGPUSType_ShaderModuleSPIRVDescriptor = WGPUSType.WGPUSType_ShaderModuleSPIRVDescriptor; 498 enum WGPUSType_ShaderModuleWGSLDescriptor = WGPUSType.WGPUSType_ShaderModuleWGSLDescriptor; 499 enum WGPUSType_AnisotropicFiltering = WGPUSType.WGPUSType_AnisotropicFiltering; 500 enum WGPUSType_Force32 = WGPUSType.WGPUSType_Force32; 501 alias WGPUSType_ = uint; 502 enum WGPUStencilOperation 503 { 504 WGPUStencilOperation_Keep = 0, 505 WGPUStencilOperation_Zero = 1, 506 WGPUStencilOperation_Replace = 2, 507 WGPUStencilOperation_Invert = 3, 508 WGPUStencilOperation_IncrementClamp = 4, 509 WGPUStencilOperation_DecrementClamp = 5, 510 WGPUStencilOperation_IncrementWrap = 6, 511 WGPUStencilOperation_DecrementWrap = 7, 512 } 513 enum WGPUStencilOperation_Keep = WGPUStencilOperation.WGPUStencilOperation_Keep; 514 enum WGPUStencilOperation_Zero = WGPUStencilOperation.WGPUStencilOperation_Zero; 515 enum WGPUStencilOperation_Replace = WGPUStencilOperation.WGPUStencilOperation_Replace; 516 enum WGPUStencilOperation_Invert = WGPUStencilOperation.WGPUStencilOperation_Invert; 517 enum WGPUStencilOperation_IncrementClamp = WGPUStencilOperation.WGPUStencilOperation_IncrementClamp; 518 enum WGPUStencilOperation_DecrementClamp = WGPUStencilOperation.WGPUStencilOperation_DecrementClamp; 519 enum WGPUStencilOperation_IncrementWrap = WGPUStencilOperation.WGPUStencilOperation_IncrementWrap; 520 enum WGPUStencilOperation_DecrementWrap = WGPUStencilOperation.WGPUStencilOperation_DecrementWrap; 521 enum WGPUStoreOp 522 { 523 WGPUStoreOp_Clear = 0, 524 WGPUStoreOp_Store = 1, 525 } 526 enum WGPUStoreOp_Clear = WGPUStoreOp.WGPUStoreOp_Clear; 527 enum WGPUStoreOp_Store = WGPUStoreOp.WGPUStoreOp_Store; 528 enum WGPUSwapChainStatus 529 { 530 WGPUSwapChainStatus_Good = 0, 531 WGPUSwapChainStatus_Suboptimal = 1, 532 WGPUSwapChainStatus_Timeout = 2, 533 WGPUSwapChainStatus_Outdated = 3, 534 WGPUSwapChainStatus_Lost = 4, 535 WGPUSwapChainStatus_OutOfMemory = 5, 536 } 537 enum WGPUSwapChainStatus_Good = WGPUSwapChainStatus.WGPUSwapChainStatus_Good; 538 enum WGPUSwapChainStatus_Suboptimal = WGPUSwapChainStatus.WGPUSwapChainStatus_Suboptimal; 539 enum WGPUSwapChainStatus_Timeout = WGPUSwapChainStatus.WGPUSwapChainStatus_Timeout; 540 enum WGPUSwapChainStatus_Outdated = WGPUSwapChainStatus.WGPUSwapChainStatus_Outdated; 541 enum WGPUSwapChainStatus_Lost = WGPUSwapChainStatus.WGPUSwapChainStatus_Lost; 542 enum WGPUSwapChainStatus_OutOfMemory = WGPUSwapChainStatus.WGPUSwapChainStatus_OutOfMemory; 543 enum WGPUTextureAspect 544 { 545 WGPUTextureAspect_All = 0, 546 WGPUTextureAspect_StencilOnly = 1, 547 WGPUTextureAspect_DepthOnly = 2, 548 } 549 enum WGPUTextureAspect_All = WGPUTextureAspect.WGPUTextureAspect_All; 550 enum WGPUTextureAspect_StencilOnly = WGPUTextureAspect.WGPUTextureAspect_StencilOnly; 551 enum WGPUTextureAspect_DepthOnly = WGPUTextureAspect.WGPUTextureAspect_DepthOnly; 552 enum WGPUTextureComponentType 553 { 554 WGPUTextureComponentType_Float = 0, 555 WGPUTextureComponentType_Sint = 1, 556 WGPUTextureComponentType_Uint = 2, 557 } 558 enum WGPUTextureComponentType_Float = WGPUTextureComponentType.WGPUTextureComponentType_Float; 559 enum WGPUTextureComponentType_Sint = WGPUTextureComponentType.WGPUTextureComponentType_Sint; 560 enum WGPUTextureComponentType_Uint = WGPUTextureComponentType.WGPUTextureComponentType_Uint; 561 enum WGPUTextureDimension 562 { 563 WGPUTextureDimension_D1 = 0, 564 WGPUTextureDimension_D2 = 1, 565 WGPUTextureDimension_D3 = 2, 566 } 567 enum WGPUTextureDimension_D1 = WGPUTextureDimension.WGPUTextureDimension_D1; 568 enum WGPUTextureDimension_D2 = WGPUTextureDimension.WGPUTextureDimension_D2; 569 enum WGPUTextureDimension_D3 = WGPUTextureDimension.WGPUTextureDimension_D3; 570 enum WGPUTextureFormat 571 { 572 WGPUTextureFormat_R8Unorm = 0, 573 WGPUTextureFormat_R8Snorm = 1, 574 WGPUTextureFormat_R8Uint = 2, 575 WGPUTextureFormat_R8Sint = 3, 576 WGPUTextureFormat_R16Uint = 4, 577 WGPUTextureFormat_R16Sint = 5, 578 WGPUTextureFormat_R16Float = 6, 579 WGPUTextureFormat_Rg8Unorm = 7, 580 WGPUTextureFormat_Rg8Snorm = 8, 581 WGPUTextureFormat_Rg8Uint = 9, 582 WGPUTextureFormat_Rg8Sint = 10, 583 WGPUTextureFormat_R32Uint = 11, 584 WGPUTextureFormat_R32Sint = 12, 585 WGPUTextureFormat_R32Float = 13, 586 WGPUTextureFormat_Rg16Uint = 14, 587 WGPUTextureFormat_Rg16Sint = 15, 588 WGPUTextureFormat_Rg16Float = 16, 589 WGPUTextureFormat_Rgba8Unorm = 17, 590 WGPUTextureFormat_Rgba8UnormSrgb = 18, 591 WGPUTextureFormat_Rgba8Snorm = 19, 592 WGPUTextureFormat_Rgba8Uint = 20, 593 WGPUTextureFormat_Rgba8Sint = 21, 594 WGPUTextureFormat_Bgra8Unorm = 22, 595 WGPUTextureFormat_Bgra8UnormSrgb = 23, 596 WGPUTextureFormat_Rgb10a2Unorm = 24, 597 WGPUTextureFormat_Rg11b10Float = 25, 598 WGPUTextureFormat_Rg32Uint = 26, 599 WGPUTextureFormat_Rg32Sint = 27, 600 WGPUTextureFormat_Rg32Float = 28, 601 WGPUTextureFormat_Rgba16Uint = 29, 602 WGPUTextureFormat_Rgba16Sint = 30, 603 WGPUTextureFormat_Rgba16Float = 31, 604 WGPUTextureFormat_Rgba32Uint = 32, 605 WGPUTextureFormat_Rgba32Sint = 33, 606 WGPUTextureFormat_Rgba32Float = 34, 607 WGPUTextureFormat_Depth32Float = 35, 608 WGPUTextureFormat_Depth24Plus = 36, 609 WGPUTextureFormat_Depth24PlusStencil8 = 37, 610 } 611 enum WGPUTextureFormat_R8Unorm = WGPUTextureFormat.WGPUTextureFormat_R8Unorm; 612 enum WGPUTextureFormat_R8Snorm = WGPUTextureFormat.WGPUTextureFormat_R8Snorm; 613 enum WGPUTextureFormat_R8Uint = WGPUTextureFormat.WGPUTextureFormat_R8Uint; 614 enum WGPUTextureFormat_R8Sint = WGPUTextureFormat.WGPUTextureFormat_R8Sint; 615 enum WGPUTextureFormat_R16Uint = WGPUTextureFormat.WGPUTextureFormat_R16Uint; 616 enum WGPUTextureFormat_R16Sint = WGPUTextureFormat.WGPUTextureFormat_R16Sint; 617 enum WGPUTextureFormat_R16Float = WGPUTextureFormat.WGPUTextureFormat_R16Float; 618 enum WGPUTextureFormat_Rg8Unorm = WGPUTextureFormat.WGPUTextureFormat_Rg8Unorm; 619 enum WGPUTextureFormat_Rg8Snorm = WGPUTextureFormat.WGPUTextureFormat_Rg8Snorm; 620 enum WGPUTextureFormat_Rg8Uint = WGPUTextureFormat.WGPUTextureFormat_Rg8Uint; 621 enum WGPUTextureFormat_Rg8Sint = WGPUTextureFormat.WGPUTextureFormat_Rg8Sint; 622 enum WGPUTextureFormat_R32Uint = WGPUTextureFormat.WGPUTextureFormat_R32Uint; 623 enum WGPUTextureFormat_R32Sint = WGPUTextureFormat.WGPUTextureFormat_R32Sint; 624 enum WGPUTextureFormat_R32Float = WGPUTextureFormat.WGPUTextureFormat_R32Float; 625 enum WGPUTextureFormat_Rg16Uint = WGPUTextureFormat.WGPUTextureFormat_Rg16Uint; 626 enum WGPUTextureFormat_Rg16Sint = WGPUTextureFormat.WGPUTextureFormat_Rg16Sint; 627 enum WGPUTextureFormat_Rg16Float = WGPUTextureFormat.WGPUTextureFormat_Rg16Float; 628 enum WGPUTextureFormat_Rgba8Unorm = WGPUTextureFormat.WGPUTextureFormat_Rgba8Unorm; 629 enum WGPUTextureFormat_Rgba8UnormSrgb = WGPUTextureFormat.WGPUTextureFormat_Rgba8UnormSrgb; 630 enum WGPUTextureFormat_Rgba8Snorm = WGPUTextureFormat.WGPUTextureFormat_Rgba8Snorm; 631 enum WGPUTextureFormat_Rgba8Uint = WGPUTextureFormat.WGPUTextureFormat_Rgba8Uint; 632 enum WGPUTextureFormat_Rgba8Sint = WGPUTextureFormat.WGPUTextureFormat_Rgba8Sint; 633 enum WGPUTextureFormat_Bgra8Unorm = WGPUTextureFormat.WGPUTextureFormat_Bgra8Unorm; 634 enum WGPUTextureFormat_Bgra8UnormSrgb = WGPUTextureFormat.WGPUTextureFormat_Bgra8UnormSrgb; 635 enum WGPUTextureFormat_Rgb10a2Unorm = WGPUTextureFormat.WGPUTextureFormat_Rgb10a2Unorm; 636 enum WGPUTextureFormat_Rg11b10Float = WGPUTextureFormat.WGPUTextureFormat_Rg11b10Float; 637 enum WGPUTextureFormat_Rg32Uint = WGPUTextureFormat.WGPUTextureFormat_Rg32Uint; 638 enum WGPUTextureFormat_Rg32Sint = WGPUTextureFormat.WGPUTextureFormat_Rg32Sint; 639 enum WGPUTextureFormat_Rg32Float = WGPUTextureFormat.WGPUTextureFormat_Rg32Float; 640 enum WGPUTextureFormat_Rgba16Uint = WGPUTextureFormat.WGPUTextureFormat_Rgba16Uint; 641 enum WGPUTextureFormat_Rgba16Sint = WGPUTextureFormat.WGPUTextureFormat_Rgba16Sint; 642 enum WGPUTextureFormat_Rgba16Float = WGPUTextureFormat.WGPUTextureFormat_Rgba16Float; 643 enum WGPUTextureFormat_Rgba32Uint = WGPUTextureFormat.WGPUTextureFormat_Rgba32Uint; 644 enum WGPUTextureFormat_Rgba32Sint = WGPUTextureFormat.WGPUTextureFormat_Rgba32Sint; 645 enum WGPUTextureFormat_Rgba32Float = WGPUTextureFormat.WGPUTextureFormat_Rgba32Float; 646 enum WGPUTextureFormat_Depth32Float = WGPUTextureFormat.WGPUTextureFormat_Depth32Float; 647 enum WGPUTextureFormat_Depth24Plus = WGPUTextureFormat.WGPUTextureFormat_Depth24Plus; 648 enum WGPUTextureFormat_Depth24PlusStencil8 = WGPUTextureFormat.WGPUTextureFormat_Depth24PlusStencil8; 649 enum WGPUTextureViewDimension 650 { 651 WGPUTextureViewDimension_D1 = 0, 652 WGPUTextureViewDimension_D2 = 1, 653 WGPUTextureViewDimension_D2Array = 2, 654 WGPUTextureViewDimension_Cube = 3, 655 WGPUTextureViewDimension_CubeArray = 4, 656 WGPUTextureViewDimension_D3 = 5, 657 } 658 enum WGPUTextureViewDimension_D1 = WGPUTextureViewDimension.WGPUTextureViewDimension_D1; 659 enum WGPUTextureViewDimension_D2 = WGPUTextureViewDimension.WGPUTextureViewDimension_D2; 660 enum WGPUTextureViewDimension_D2Array = WGPUTextureViewDimension.WGPUTextureViewDimension_D2Array; 661 enum WGPUTextureViewDimension_Cube = WGPUTextureViewDimension.WGPUTextureViewDimension_Cube; 662 enum WGPUTextureViewDimension_CubeArray = WGPUTextureViewDimension.WGPUTextureViewDimension_CubeArray; 663 enum WGPUTextureViewDimension_D3 = WGPUTextureViewDimension.WGPUTextureViewDimension_D3; 664 enum WGPUVertexFormat 665 { 666 WGPUVertexFormat_Uchar2 = 0, 667 WGPUVertexFormat_Uchar4 = 1, 668 WGPUVertexFormat_Char2 = 2, 669 WGPUVertexFormat_Char4 = 3, 670 WGPUVertexFormat_Uchar2Norm = 4, 671 WGPUVertexFormat_Uchar4Norm = 5, 672 WGPUVertexFormat_Char2Norm = 6, 673 WGPUVertexFormat_Char4Norm = 7, 674 WGPUVertexFormat_Ushort2 = 8, 675 WGPUVertexFormat_Ushort4 = 9, 676 WGPUVertexFormat_Short2 = 10, 677 WGPUVertexFormat_Short4 = 11, 678 WGPUVertexFormat_Ushort2Norm = 12, 679 WGPUVertexFormat_Ushort4Norm = 13, 680 WGPUVertexFormat_Short2Norm = 14, 681 WGPUVertexFormat_Short4Norm = 15, 682 WGPUVertexFormat_Half2 = 16, 683 WGPUVertexFormat_Half4 = 17, 684 WGPUVertexFormat_Float = 18, 685 WGPUVertexFormat_Float2 = 19, 686 WGPUVertexFormat_Float3 = 20, 687 WGPUVertexFormat_Float4 = 21, 688 WGPUVertexFormat_Uint = 22, 689 WGPUVertexFormat_Uint2 = 23, 690 WGPUVertexFormat_Uint3 = 24, 691 WGPUVertexFormat_Uint4 = 25, 692 WGPUVertexFormat_Int = 26, 693 WGPUVertexFormat_Int2 = 27, 694 WGPUVertexFormat_Int3 = 28, 695 WGPUVertexFormat_Int4 = 29, 696 } 697 enum WGPUVertexFormat_Uchar2 = WGPUVertexFormat.WGPUVertexFormat_Uchar2; 698 enum WGPUVertexFormat_Uchar4 = WGPUVertexFormat.WGPUVertexFormat_Uchar4; 699 enum WGPUVertexFormat_Char2 = WGPUVertexFormat.WGPUVertexFormat_Char2; 700 enum WGPUVertexFormat_Char4 = WGPUVertexFormat.WGPUVertexFormat_Char4; 701 enum WGPUVertexFormat_Uchar2Norm = WGPUVertexFormat.WGPUVertexFormat_Uchar2Norm; 702 enum WGPUVertexFormat_Uchar4Norm = WGPUVertexFormat.WGPUVertexFormat_Uchar4Norm; 703 enum WGPUVertexFormat_Char2Norm = WGPUVertexFormat.WGPUVertexFormat_Char2Norm; 704 enum WGPUVertexFormat_Char4Norm = WGPUVertexFormat.WGPUVertexFormat_Char4Norm; 705 enum WGPUVertexFormat_Ushort2 = WGPUVertexFormat.WGPUVertexFormat_Ushort2; 706 enum WGPUVertexFormat_Ushort4 = WGPUVertexFormat.WGPUVertexFormat_Ushort4; 707 enum WGPUVertexFormat_Short2 = WGPUVertexFormat.WGPUVertexFormat_Short2; 708 enum WGPUVertexFormat_Short4 = WGPUVertexFormat.WGPUVertexFormat_Short4; 709 enum WGPUVertexFormat_Ushort2Norm = WGPUVertexFormat.WGPUVertexFormat_Ushort2Norm; 710 enum WGPUVertexFormat_Ushort4Norm = WGPUVertexFormat.WGPUVertexFormat_Ushort4Norm; 711 enum WGPUVertexFormat_Short2Norm = WGPUVertexFormat.WGPUVertexFormat_Short2Norm; 712 enum WGPUVertexFormat_Short4Norm = WGPUVertexFormat.WGPUVertexFormat_Short4Norm; 713 enum WGPUVertexFormat_Half2 = WGPUVertexFormat.WGPUVertexFormat_Half2; 714 enum WGPUVertexFormat_Half4 = WGPUVertexFormat.WGPUVertexFormat_Half4; 715 enum WGPUVertexFormat_Float = WGPUVertexFormat.WGPUVertexFormat_Float; 716 enum WGPUVertexFormat_Float2 = WGPUVertexFormat.WGPUVertexFormat_Float2; 717 enum WGPUVertexFormat_Float3 = WGPUVertexFormat.WGPUVertexFormat_Float3; 718 enum WGPUVertexFormat_Float4 = WGPUVertexFormat.WGPUVertexFormat_Float4; 719 enum WGPUVertexFormat_Uint = WGPUVertexFormat.WGPUVertexFormat_Uint; 720 enum WGPUVertexFormat_Uint2 = WGPUVertexFormat.WGPUVertexFormat_Uint2; 721 enum WGPUVertexFormat_Uint3 = WGPUVertexFormat.WGPUVertexFormat_Uint3; 722 enum WGPUVertexFormat_Uint4 = WGPUVertexFormat.WGPUVertexFormat_Uint4; 723 enum WGPUVertexFormat_Int = WGPUVertexFormat.WGPUVertexFormat_Int; 724 enum WGPUVertexFormat_Int2 = WGPUVertexFormat.WGPUVertexFormat_Int2; 725 enum WGPUVertexFormat_Int3 = WGPUVertexFormat.WGPUVertexFormat_Int3; 726 enum WGPUVertexFormat_Int4 = WGPUVertexFormat.WGPUVertexFormat_Int4; 727 struct WGPUComputePass; 728 // https://docs.piston.rs/conrod/wgpu_types/type.BufferSize.html 729 /// Integral type used for buffer slice sizes. 730 alias WGPUOption_BufferSize = uint64_t; 731 struct WGPURenderBundleEncoder; 732 struct WGPURenderPass; 733 alias WGPUId_Adapter_Dummy = ulong; 734 alias WGPUAdapterId = ulong; 735 alias WGPUFeatures = c_ulong; 736 alias uint64_t = ulong; 737 alias uint32_t = uint; 738 alias uint16_t = ushort; 739 alias uint8_t = ubyte; 740 alias int64_t = c_long; 741 alias int32_t = int; 742 struct WGPUCAdapterInfo 743 { 744 char* name; 745 c_ulong name_length; 746 c_ulong vendor; 747 c_ulong device; 748 ubyte device_type; 749 ubyte backend; 750 } 751 struct WGPUCLimits 752 { 753 uint max_bind_groups; 754 } 755 alias WGPUId_Device_Dummy = ulong; 756 alias WGPUDeviceId = ulong; 757 alias WGPUId_BindGroup_Dummy = ulong; 758 alias WGPUBindGroupId = ulong; 759 alias WGPUId_BindGroupLayout_Dummy = ulong; 760 alias WGPUBindGroupLayoutId = ulong; 761 alias WGPUId_Buffer_Dummy = ulong; 762 alias WGPUBufferId = ulong; 763 alias WGPUBufferAddress = c_ulong; 764 alias WGPUBufferSize = ulong; 765 alias WGPUBufferMapCallback = void function(WGPUBufferMapAsyncStatus, ubyte*); 766 alias WGPUId_CommandBuffer_Dummy = ulong; 767 alias WGPUCommandBufferId = ulong; 768 alias WGPUCommandEncoderId = ulong; 769 struct WGPUComputePassDescriptor 770 { 771 uint todo; 772 } 773 alias WGPUId_TextureView_Dummy = ulong; 774 alias WGPUTextureViewId = ulong; 775 struct WGPUColor 776 { 777 double r; 778 double g; 779 double b; 780 double a; 781 } 782 alias int16_t = short; 783 alias int8_t = byte; 784 struct WGPUPassChannel_Color 785 { 786 WGPULoadOp load_op; 787 WGPUStoreOp store_op; 788 WGPUColor clear_value; 789 bool read_only; 790 } 791 struct WGPURenderPassColorAttachmentDescriptorBase_TextureViewId 792 { 793 ulong attachment; 794 ulong resolve_target; 795 WGPUPassChannel_Color channel; 796 } 797 alias WGPURenderPassColorAttachmentDescriptor = WGPURenderPassColorAttachmentDescriptorBase_TextureViewId; 798 struct WGPUPassChannel_f32 799 { 800 WGPULoadOp load_op; 801 WGPUStoreOp store_op; 802 float clear_value; 803 bool read_only; 804 } 805 struct WGPUPassChannel_u32 806 { 807 WGPULoadOp load_op; 808 WGPUStoreOp store_op; 809 uint clear_value; 810 bool read_only; 811 } 812 struct WGPURenderPassDepthStencilAttachmentDescriptorBase_TextureViewId 813 { 814 ulong attachment; 815 WGPUPassChannel_f32 depth; 816 WGPUPassChannel_u32 stencil; 817 } 818 alias WGPURenderPassDepthStencilAttachmentDescriptor = WGPURenderPassDepthStencilAttachmentDescriptorBase_TextureViewId; 819 struct WGPURenderPassDescriptor 820 { 821 const(WGPURenderPassColorAttachmentDescriptorBase_TextureViewId)* color_attachments; 822 c_ulong color_attachments_length; 823 const(WGPURenderPassDepthStencilAttachmentDescriptorBase_TextureViewId)* depth_stencil_attachment; 824 } 825 struct WGPUTextureDataLayout 826 { 827 c_ulong offset; 828 uint bytes_per_row; 829 uint rows_per_image; 830 } 831 struct WGPUBufferCopyView 832 { 833 ulong buffer; 834 WGPUTextureDataLayout layout; 835 } 836 alias WGPUId_Texture_Dummy = ulong; 837 alias WGPUTextureId = ulong; 838 struct WGPUOrigin3d 839 { 840 uint x; 841 uint y; 842 uint z; 843 } 844 struct WGPUTextureCopyView 845 { 846 ulong texture; 847 uint mip_level; 848 WGPUOrigin3d origin; 849 } 850 struct WGPUExtent3d 851 { 852 uint width; 853 uint height; 854 uint depth; 855 } 856 struct WGPUCommandBufferDescriptor 857 { 858 uint todo; 859 } 860 alias WGPURawString = const(char)*; 861 alias WGPUDynamicOffset = uint; 862 alias WGPUId_ComputePipeline_Dummy = ulong; 863 alias WGPUComputePipelineId = ulong; 864 alias WGPUId_Surface = ulong; 865 alias WGPUSurfaceId = ulong; 866 alias WGPULabel = const(char)*; 867 struct WGPUBindGroupEntry 868 { 869 uint binding; 870 ulong buffer; 871 c_ulong offset; 872 ulong size; 873 ulong sampler; 874 ulong texture_view; 875 } 876 struct WGPUBindGroupDescriptor 877 { 878 const(char)* label; 879 ulong layout; 880 const(WGPUBindGroupEntry)* entries; 881 c_ulong entries_length; 882 } 883 alias WGPUShaderStage = uint; 884 union pthread_barrierattr_t 885 { 886 char[4] __size; 887 int __align; 888 } 889 struct WGPUBindGroupLayoutEntry 890 { 891 uint binding; 892 uint visibility; 893 uint ty; 894 bool has_dynamic_offset; 895 c_ulong min_buffer_binding_size; 896 bool multisampled; 897 WGPUTextureViewDimension view_dimension; 898 WGPUTextureComponentType texture_component_type; 899 WGPUTextureFormat storage_texture_format; 900 c_ulong count; 901 } 902 struct WGPUBindGroupLayoutDescriptor 903 { 904 const(char)* label; 905 const(WGPUBindGroupLayoutEntry)* entries; 906 c_ulong entries_length; 907 } 908 alias WGPUBufferUsage = uint; 909 union pthread_barrier_t 910 { 911 char[32] __size; 912 c_long __align; 913 } 914 alias pthread_spinlock_t = int; 915 union pthread_rwlockattr_t 916 { 917 char[8] __size; 918 c_long __align; 919 } 920 struct WGPUBufferDescriptor 921 { 922 const(char)* label; 923 c_ulong size; 924 uint usage; 925 bool mapped_at_creation; 926 } 927 struct WGPUCommandEncoderDescriptor 928 { 929 const(char)* label; 930 } 931 alias WGPUId_PipelineLayout_Dummy = ulong; 932 alias WGPUPipelineLayoutId = ulong; 933 alias WGPUId_ShaderModule_Dummy = ulong; 934 alias WGPUShaderModuleId = ulong; 935 struct WGPUProgrammableStageDescriptor 936 { 937 ulong module_; 938 const(char)* entry_point; 939 } 940 struct WGPUComputePipelineDescriptor 941 { 942 ulong layout; 943 WGPUProgrammableStageDescriptor compute_stage; 944 } 945 struct WGPUPipelineLayoutDescriptor 946 { 947 const(ulong)* bind_group_layouts; 948 c_ulong bind_group_layouts_length; 949 } 950 alias WGPURenderBundleEncoderId = WGPURenderBundleEncoder*; 951 struct WGPURenderBundleEncoderDescriptor 952 { 953 const(char)* label; 954 const(WGPUTextureFormat)* color_formats; 955 c_ulong color_formats_length; 956 const(WGPUTextureFormat)* depth_stencil_format; 957 uint sample_count; 958 } 959 alias WGPUId_RenderPipeline_Dummy = ulong; 960 alias WGPURenderPipelineId = ulong; 961 struct WGPURasterizationStateDescriptor 962 { 963 WGPUFrontFace front_face; 964 WGPUCullMode cull_mode; 965 int depth_bias; 966 float depth_bias_slope_scale; 967 float depth_bias_clamp; 968 } 969 struct WGPUBlendDescriptor 970 { 971 WGPUBlendFactor src_factor; 972 WGPUBlendFactor dst_factor; 973 WGPUBlendOperation operation; 974 } 975 alias WGPUColorWrite = uint; 976 union pthread_rwlock_t 977 { 978 __pthread_rwlock_arch_t __data; 979 char[56] __size; 980 c_long __align; 981 } 982 union pthread_cond_t 983 { 984 __pthread_cond_s __data; 985 char[48] __size; 986 long __align; 987 } 988 struct WGPUColorStateDescriptor 989 { 990 WGPUTextureFormat format; 991 WGPUBlendDescriptor alpha_blend; 992 WGPUBlendDescriptor color_blend; 993 uint write_mask; 994 } 995 struct WGPUStencilStateFaceDescriptor 996 { 997 WGPUCompareFunction compare; 998 WGPUStencilOperation fail_op; 999 WGPUStencilOperation depth_fail_op; 1000 WGPUStencilOperation pass_op; 1001 } 1002 struct WGPUDepthStencilStateDescriptor 1003 { 1004 WGPUTextureFormat format; 1005 bool depth_write_enabled; 1006 WGPUCompareFunction depth_compare; 1007 WGPUStencilStateFaceDescriptor stencil_front; 1008 WGPUStencilStateFaceDescriptor stencil_back; 1009 uint stencil_read_mask; 1010 uint stencil_write_mask; 1011 } 1012 alias WGPUShaderLocation = uint; 1013 struct WGPUVertexAttributeDescriptor 1014 { 1015 c_ulong offset; 1016 WGPUVertexFormat format; 1017 uint shader_location; 1018 } 1019 struct WGPUVertexBufferLayoutDescriptor 1020 { 1021 c_ulong array_stride; 1022 WGPUInputStepMode step_mode; 1023 const(WGPUVertexAttributeDescriptor)* attributes; 1024 c_ulong attributes_length; 1025 } 1026 struct WGPUVertexStateDescriptor 1027 { 1028 WGPUIndexFormat index_format; 1029 const(WGPUVertexBufferLayoutDescriptor)* vertex_buffers; 1030 c_ulong vertex_buffers_length; 1031 } 1032 struct WGPURenderPipelineDescriptor 1033 { 1034 ulong layout; 1035 WGPUProgrammableStageDescriptor vertex_stage; 1036 const(WGPUProgrammableStageDescriptor)* fragment_stage; 1037 WGPUPrimitiveTopology primitive_topology; 1038 const(WGPURasterizationStateDescriptor)* rasterization_state; 1039 const(WGPUColorStateDescriptor)* color_states; 1040 c_ulong color_states_length; 1041 const(WGPUDepthStencilStateDescriptor)* depth_stencil_state; 1042 WGPUVertexStateDescriptor vertex_state; 1043 uint sample_count; 1044 uint sample_mask; 1045 bool alpha_to_coverage_enabled; 1046 } 1047 alias WGPUId_Sampler_Dummy = ulong; 1048 alias WGPUSamplerId = ulong; 1049 struct WGPUSamplerDescriptor 1050 { 1051 const(WGPUChainedStruct)* next_in_chain; 1052 const(char)* label; 1053 WGPUAddressMode address_mode_u; 1054 WGPUAddressMode address_mode_v; 1055 WGPUAddressMode address_mode_w; 1056 WGPUFilterMode mag_filter; 1057 WGPUFilterMode min_filter; 1058 WGPUFilterMode mipmap_filter; 1059 float lod_min_clamp; 1060 float lod_max_clamp; 1061 WGPUCompareFunction compare; 1062 } 1063 struct WGPUShaderSource 1064 { 1065 const(uint)* bytes; 1066 c_ulong length; 1067 } 1068 alias WGPUId_SwapChain_Dummy = ulong; 1069 alias WGPUSwapChainId = ulong; 1070 alias WGPUTextureUsage = uint; 1071 union pthread_mutex_t 1072 { 1073 __pthread_mutex_s __data; 1074 char[40] __size; 1075 c_long __align; 1076 } 1077 struct WGPUSwapChainDescriptor 1078 { 1079 uint usage; 1080 WGPUTextureFormat format; 1081 uint width; 1082 uint height; 1083 WGPUPresentMode present_mode; 1084 } 1085 struct WGPUTextureDescriptor 1086 { 1087 const(char)* label; 1088 WGPUExtent3d size; 1089 uint mip_level_count; 1090 uint sample_count; 1091 WGPUTextureDimension dimension; 1092 WGPUTextureFormat format; 1093 uint usage; 1094 } 1095 alias WGPUQueueId = ulong; 1096 alias WGPUId_RenderBundle = ulong; 1097 alias WGPURenderBundleId = ulong; 1098 struct WGPURenderBundleDescriptor_Label 1099 { 1100 const(char)* label; 1101 } 1102 struct WGPURequestAdapterOptions 1103 { 1104 WGPUPowerPreference power_preference; 1105 ulong compatible_surface; 1106 } 1107 alias WGPUBackendBit = uint; 1108 alias WGPURequestAdapterCallback = void function(ulong, void*); 1109 alias WGPULogCallback = void function(int, const(char)*); 1110 struct WGPUSwapChainOutput 1111 { 1112 WGPUSwapChainStatus status; 1113 ulong view_id; 1114 } 1115 struct WGPUTextureViewDescriptor 1116 { 1117 const(char)* label; 1118 WGPUTextureFormat format; 1119 WGPUTextureViewDimension dimension; 1120 WGPUTextureAspect aspect; 1121 uint base_mip_level; 1122 uint level_count; 1123 uint base_array_layer; 1124 uint array_layer_count; 1125 } 1126 struct WGPUAnisotropicSamplerDescriptorExt 1127 { 1128 const(WGPUChainedStruct)* next_in_chain; 1129 uint s_type; 1130 ubyte anisotropic_clamp; 1131 } 1132 void wgpu_adapter_destroy(ulong) @nogc nothrow; 1133 c_ulong wgpu_adapter_features(ulong) @nogc nothrow; 1134 void wgpu_adapter_get_info(ulong, WGPUCAdapterInfo*) @nogc nothrow; 1135 WGPUCLimits wgpu_adapter_limits(ulong) @nogc nothrow; 1136 ulong wgpu_adapter_request_device(ulong, c_ulong, const(WGPUCLimits)*, bool, const(char)*) @nogc nothrow; 1137 void wgpu_bind_group_destroy(ulong) @nogc nothrow; 1138 void wgpu_bind_group_layout_destroy(ulong) @nogc nothrow; 1139 void wgpu_buffer_destroy(ulong) @nogc nothrow; 1140 ubyte* wgpu_buffer_get_mapped_range(ulong, c_ulong, ulong) @nogc nothrow; 1141 void wgpu_buffer_map_read_async(ulong, c_ulong, c_ulong, void function(WGPUBufferMapAsyncStatus, ubyte*), ubyte*) @nogc nothrow; 1142 void wgpu_buffer_map_write_async(ulong, c_ulong, c_ulong, void function(WGPUBufferMapAsyncStatus, ubyte*), ubyte*) @nogc nothrow; 1143 void wgpu_buffer_unmap(ulong) @nogc nothrow; 1144 void wgpu_command_buffer_destroy(ulong) @nogc nothrow; 1145 WGPUComputePass* wgpu_command_encoder_begin_compute_pass(ulong, const(WGPUComputePassDescriptor)*) @nogc nothrow; 1146 WGPURenderPass* wgpu_command_encoder_begin_render_pass(ulong, const(WGPURenderPassDescriptor)*) @nogc nothrow; 1147 void wgpu_command_encoder_copy_buffer_to_buffer(ulong, ulong, c_ulong, ulong, c_ulong, c_ulong) @nogc nothrow; 1148 void wgpu_command_encoder_copy_buffer_to_texture(ulong, const(WGPUBufferCopyView)*, const(WGPUTextureCopyView)*, const(WGPUExtent3d)*) @nogc nothrow; 1149 void wgpu_command_encoder_copy_texture_to_buffer(ulong, const(WGPUTextureCopyView)*, const(WGPUBufferCopyView)*, const(WGPUExtent3d)*) @nogc nothrow; 1150 void wgpu_command_encoder_copy_texture_to_texture(ulong, const(WGPUTextureCopyView)*, const(WGPUTextureCopyView)*, const(WGPUExtent3d)*) @nogc nothrow; 1151 void wgpu_command_encoder_destroy(ulong) @nogc nothrow; 1152 ulong wgpu_command_encoder_finish(ulong, const(WGPUCommandBufferDescriptor)*) @nogc nothrow; 1153 void wgpu_compute_pass_destroy(WGPUComputePass*) @nogc nothrow; 1154 void wgpu_compute_pass_dispatch(WGPUComputePass*, uint, uint, uint) @nogc nothrow; 1155 void wgpu_compute_pass_dispatch_indirect(WGPUComputePass*, ulong, c_ulong) @nogc nothrow; 1156 void wgpu_compute_pass_end_pass(WGPUComputePass*) @nogc nothrow; 1157 void wgpu_compute_pass_insert_debug_marker(WGPUComputePass*, const(char)*, uint) @nogc nothrow; 1158 void wgpu_compute_pass_pop_debug_group(WGPUComputePass*) @nogc nothrow; 1159 void wgpu_compute_pass_push_debug_group(WGPUComputePass*, const(char)*, uint) @nogc nothrow; 1160 void wgpu_compute_pass_set_bind_group(WGPUComputePass*, uint, ulong, const(uint)*, c_ulong) @nogc nothrow; 1161 void wgpu_compute_pass_set_pipeline(WGPUComputePass*, ulong) @nogc nothrow; 1162 void wgpu_compute_pipeline_destroy(ulong) @nogc nothrow; 1163 ulong wgpu_create_surface_from_android(void*) @nogc nothrow; 1164 ulong wgpu_create_surface_from_metal_layer(void*) @nogc nothrow; 1165 ulong wgpu_create_surface_from_wayland(void*, void*) @nogc nothrow; 1166 ulong wgpu_create_surface_from_windows_hwnd(void*, void*) @nogc nothrow; 1167 ulong wgpu_create_surface_from_xlib(const(void)**, c_ulong) @nogc nothrow; 1168 ulong wgpu_device_create_bind_group(ulong, const(WGPUBindGroupDescriptor)*) @nogc nothrow; 1169 ulong wgpu_device_create_bind_group_layout(ulong, const(WGPUBindGroupLayoutDescriptor)*) @nogc nothrow; 1170 ulong wgpu_device_create_buffer(ulong, const(WGPUBufferDescriptor)*) @nogc nothrow; 1171 ulong wgpu_device_create_command_encoder(ulong, const(WGPUCommandEncoderDescriptor)*) @nogc nothrow; 1172 ulong wgpu_device_create_compute_pipeline(ulong, const(WGPUComputePipelineDescriptor)*) @nogc nothrow; 1173 ulong wgpu_device_create_pipeline_layout(ulong, const(WGPUPipelineLayoutDescriptor)*) @nogc nothrow; 1174 WGPURenderBundleEncoder* wgpu_device_create_render_bundle_encoder(ulong, const(WGPURenderBundleEncoderDescriptor)*) @nogc nothrow; 1175 ulong wgpu_device_create_render_pipeline(ulong, const(WGPURenderPipelineDescriptor)*) @nogc nothrow; 1176 ulong wgpu_device_create_sampler(ulong, const(WGPUSamplerDescriptor)*) @nogc nothrow; 1177 ulong wgpu_device_create_shader_module(ulong, WGPUShaderSource) @nogc nothrow; 1178 ulong wgpu_device_create_swap_chain(ulong, ulong, const(WGPUSwapChainDescriptor)*) @nogc nothrow; 1179 ulong wgpu_device_create_texture(ulong, const(WGPUTextureDescriptor)*) @nogc nothrow; 1180 void wgpu_device_destroy(ulong) @nogc nothrow; 1181 c_ulong wgpu_device_features(ulong) @nogc nothrow; 1182 ulong wgpu_device_get_default_queue(ulong) @nogc nothrow; 1183 WGPUCLimits wgpu_device_limits(ulong) @nogc nothrow; 1184 void wgpu_device_poll(ulong, bool) @nogc nothrow; 1185 uint wgpu_get_version() @nogc nothrow; 1186 void wgpu_pipeline_layout_destroy(ulong) @nogc nothrow; 1187 void wgpu_queue_submit(ulong, const(ulong)*, c_ulong) @nogc nothrow; 1188 void wgpu_queue_write_buffer(ulong, ulong, c_ulong, const(ubyte)*, c_ulong) @nogc nothrow; 1189 void wgpu_queue_write_texture(ulong, const(WGPUTextureCopyView)*, const(ubyte)*, c_ulong, const(WGPUTextureDataLayout)*, const(WGPUExtent3d)*) @nogc nothrow; 1190 void wgpu_render_bundle_destroy(ulong) @nogc nothrow; 1191 void wgpu_render_bundle_draw(WGPURenderBundleEncoder*, uint, uint, uint, uint) @nogc nothrow; 1192 void wgpu_render_bundle_draw_indexed(WGPURenderBundleEncoder*, uint, uint, uint, int, uint) @nogc nothrow; 1193 void wgpu_render_bundle_draw_indirect(WGPURenderBundleEncoder*, ulong, c_ulong) @nogc nothrow; 1194 ulong wgpu_render_bundle_encoder_finish(WGPURenderBundleEncoder*, const(WGPURenderBundleDescriptor_Label)*) @nogc nothrow; 1195 void wgpu_render_bundle_insert_debug_marker(WGPURenderBundleEncoder*, const(char)*) @nogc nothrow; 1196 void wgpu_render_bundle_pop_debug_group(WGPURenderBundleEncoder*) @nogc nothrow; 1197 void wgpu_render_bundle_push_debug_group(WGPURenderBundleEncoder*, const(char)*) @nogc nothrow; 1198 void wgpu_render_bundle_set_bind_group(WGPURenderBundleEncoder*, uint, ulong, const(uint)*, c_ulong) @nogc nothrow; 1199 void wgpu_render_bundle_set_index_buffer(WGPURenderBundleEncoder*, ulong, c_ulong, WGPUOption_BufferSize) @nogc nothrow; 1200 void wgpu_render_bundle_set_pipeline(WGPURenderBundleEncoder*, ulong) @nogc nothrow; 1201 void wgpu_render_bundle_set_vertex_buffer(WGPURenderBundleEncoder*, uint, ulong, c_ulong, WGPUOption_BufferSize) @nogc nothrow; 1202 void wgpu_render_pass_bundle_indexed_indirect(WGPURenderBundleEncoder*, ulong, c_ulong) @nogc nothrow; 1203 void wgpu_render_pass_destroy(WGPURenderPass*) @nogc nothrow; 1204 void wgpu_render_pass_draw(WGPURenderPass*, uint, uint, uint, uint) @nogc nothrow; 1205 void wgpu_render_pass_draw_indexed(WGPURenderPass*, uint, uint, uint, int, uint) @nogc nothrow; 1206 void wgpu_render_pass_draw_indexed_indirect(WGPURenderPass*, ulong, c_ulong) @nogc nothrow; 1207 void wgpu_render_pass_draw_indirect(WGPURenderPass*, ulong, c_ulong) @nogc nothrow; 1208 void wgpu_render_pass_end_pass(WGPURenderPass*) @nogc nothrow; 1209 void wgpu_render_pass_insert_debug_marker(WGPURenderPass*, const(char)*, uint) @nogc nothrow; 1210 void wgpu_render_pass_multi_draw_indexed_indirect(WGPURenderPass*, ulong, c_ulong, uint) @nogc nothrow; 1211 void wgpu_render_pass_multi_draw_indexed_indirect_count(WGPURenderPass*, ulong, c_ulong, ulong, c_ulong, uint) @nogc nothrow; 1212 void wgpu_render_pass_multi_draw_indirect(WGPURenderPass*, ulong, c_ulong, uint) @nogc nothrow; 1213 void wgpu_render_pass_multi_draw_indirect_count(WGPURenderPass*, ulong, c_ulong, ulong, c_ulong, uint) @nogc nothrow; 1214 void wgpu_render_pass_pop_debug_group(WGPURenderPass*) @nogc nothrow; 1215 void wgpu_render_pass_push_debug_group(WGPURenderPass*, const(char)*, uint) @nogc nothrow; 1216 void wgpu_render_pass_set_bind_group(WGPURenderPass*, uint, ulong, const(uint)*, c_ulong) @nogc nothrow; 1217 void wgpu_render_pass_set_blend_color(WGPURenderPass*, const(WGPUColor)*) @nogc nothrow; 1218 void wgpu_render_pass_set_index_buffer(WGPURenderPass*, ulong, c_ulong, WGPUOption_BufferSize) @nogc nothrow; 1219 void wgpu_render_pass_set_pipeline(WGPURenderPass*, ulong) @nogc nothrow; 1220 void wgpu_render_pass_set_scissor_rect(WGPURenderPass*, uint, uint, uint, uint) @nogc nothrow; 1221 void wgpu_render_pass_set_stencil_reference(WGPURenderPass*, uint) @nogc nothrow; 1222 void wgpu_render_pass_set_vertex_buffer(WGPURenderPass*, uint, ulong, c_ulong, WGPUOption_BufferSize) @nogc nothrow; 1223 void wgpu_render_pass_set_viewport(WGPURenderPass*, float, float, float, float, float, float) @nogc nothrow; 1224 void wgpu_render_pipeline_destroy(ulong) @nogc nothrow; 1225 void wgpu_request_adapter_async(const(WGPURequestAdapterOptions)*, uint, bool, void function(ulong, void*), void*) @nogc nothrow; 1226 void wgpu_sampler_destroy(ulong) @nogc nothrow; 1227 void wgpu_set_log_callback(void function(int, const(char)*)) @nogc nothrow; 1228 int wgpu_set_log_level(WGPULogLevel) @nogc nothrow; 1229 void wgpu_shader_module_destroy(ulong) @nogc nothrow; 1230 WGPUSwapChainOutput wgpu_swap_chain_get_next_texture(ulong) @nogc nothrow; 1231 void wgpu_swap_chain_present(ulong) @nogc nothrow; 1232 ulong wgpu_texture_create_view(ulong, const(WGPUTextureViewDescriptor)*) @nogc nothrow; 1233 void wgpu_texture_destroy(ulong) @nogc nothrow; 1234 void wgpu_texture_view_destroy(ulong) @nogc nothrow; 1235 union pthread_attr_t 1236 { 1237 char[56] __size; 1238 c_long __align; 1239 } 1240 pragma(mangle, "alloca") void* alloca_(c_ulong) @nogc nothrow; 1241 alias pthread_once_t = int; 1242 alias pthread_key_t = uint; 1243 union pthread_condattr_t 1244 { 1245 char[4] __size; 1246 int __align; 1247 } 1248 union pthread_mutexattr_t 1249 { 1250 char[4] __size; 1251 int __align; 1252 } 1253 alias pthread_t = c_ulong; 1254 struct __pthread_rwlock_arch_t 1255 { 1256 uint __readers; 1257 uint __writers; 1258 uint __wrphase_futex; 1259 uint __writers_futex; 1260 uint __pad3; 1261 uint __pad4; 1262 int __cur_writer; 1263 int __shared; 1264 byte __rwelision; 1265 ubyte[7] __pad1; 1266 c_ulong __pad2; 1267 uint __flags; 1268 } 1269 alias size_t = c_ulong; 1270 alias wchar_t = int; 1271 alias _Float64x = real; 1272 alias _Float32x = double; 1273 alias _Float64 = double; 1274 alias _Float32 = float; 1275 alias int_least8_t = byte; 1276 alias int_least16_t = short; 1277 alias int_least32_t = int; 1278 alias int_least64_t = c_long; 1279 alias uint_least8_t = ubyte; 1280 alias uint_least16_t = ushort; 1281 alias uint_least32_t = uint; 1282 alias uint_least64_t = c_ulong; 1283 alias int_fast8_t = byte; 1284 alias int_fast16_t = c_long; 1285 alias int_fast32_t = c_long; 1286 alias int_fast64_t = c_long; 1287 alias uint_fast8_t = ubyte; 1288 alias uint_fast16_t = c_ulong; 1289 alias uint_fast32_t = c_ulong; 1290 alias uint_fast64_t = c_ulong; 1291 alias intptr_t = c_long; 1292 alias uintptr_t = c_ulong; 1293 alias intmax_t = c_long; 1294 alias uintmax_t = c_ulong; 1295 int getloadavg(double*, int) @nogc nothrow; 1296 int getsubopt(char**, char**, char**) @nogc nothrow; 1297 int rpmatch(const(char)*) @nogc nothrow; 1298 c_ulong wcstombs(char*, const(int)*, c_ulong) @nogc nothrow; 1299 c_ulong mbstowcs(int*, const(char)*, c_ulong) @nogc nothrow; 1300 int wctomb(char*, int) @nogc nothrow; 1301 int mbtowc(int*, const(char)*, c_ulong) @nogc nothrow; 1302 int mblen(const(char)*, c_ulong) @nogc nothrow; 1303 int qfcvt_r(real, int, int*, int*, char*, c_ulong) @nogc nothrow; 1304 int qecvt_r(real, int, int*, int*, char*, c_ulong) @nogc nothrow; 1305 int fcvt_r(double, int, int*, int*, char*, c_ulong) @nogc nothrow; 1306 int ecvt_r(double, int, int*, int*, char*, c_ulong) @nogc nothrow; 1307 char* qgcvt(real, int, char*) @nogc nothrow; 1308 char* qfcvt(real, int, int*, int*) @nogc nothrow; 1309 char* qecvt(real, int, int*, int*) @nogc nothrow; 1310 char* gcvt(double, int, char*) @nogc nothrow; 1311 struct div_t 1312 { 1313 int quot; 1314 int rem; 1315 } 1316 struct ldiv_t 1317 { 1318 c_long quot; 1319 c_long rem; 1320 } 1321 struct lldiv_t 1322 { 1323 long quot; 1324 long rem; 1325 } 1326 char* fcvt(double, int, int*, int*) @nogc nothrow; 1327 c_ulong __ctype_get_mb_cur_max() @nogc nothrow; 1328 double atof(const(char)*) @nogc nothrow; 1329 int atoi(const(char)*) @nogc nothrow; 1330 c_long atol(const(char)*) @nogc nothrow; 1331 long atoll(const(char)*) @nogc nothrow; 1332 double strtod(const(char)*, char**) @nogc nothrow; 1333 float strtof(const(char)*, char**) @nogc nothrow; 1334 real strtold(const(char)*, char**) @nogc nothrow; 1335 c_long strtol(const(char)*, char**, int) @nogc nothrow; 1336 c_ulong strtoul(const(char)*, char**, int) @nogc nothrow; 1337 long strtoq(const(char)*, char**, int) @nogc nothrow; 1338 ulong strtouq(const(char)*, char**, int) @nogc nothrow; 1339 long strtoll(const(char)*, char**, int) @nogc nothrow; 1340 ulong strtoull(const(char)*, char**, int) @nogc nothrow; 1341 char* l64a(c_long) @nogc nothrow; 1342 c_long a64l(const(char)*) @nogc nothrow; 1343 c_long random() @nogc nothrow; 1344 void srandom(uint) @nogc nothrow; 1345 char* initstate(uint, char*, c_ulong) @nogc nothrow; 1346 char* setstate(char*) @nogc nothrow; 1347 struct random_data 1348 { 1349 int* fptr; 1350 int* rptr; 1351 int* state; 1352 int rand_type; 1353 int rand_deg; 1354 int rand_sep; 1355 int* end_ptr; 1356 } 1357 int random_r(random_data*, int*) @nogc nothrow; 1358 int srandom_r(uint, random_data*) @nogc nothrow; 1359 int initstate_r(uint, char*, c_ulong, random_data*) @nogc nothrow; 1360 int setstate_r(char*, random_data*) @nogc nothrow; 1361 int rand() @nogc nothrow; 1362 void srand(uint) @nogc nothrow; 1363 int rand_r(uint*) @nogc nothrow; 1364 double drand48() @nogc nothrow; 1365 double erand48(ushort*) @nogc nothrow; 1366 c_long lrand48() @nogc nothrow; 1367 c_long nrand48(ushort*) @nogc nothrow; 1368 c_long mrand48() @nogc nothrow; 1369 c_long jrand48(ushort*) @nogc nothrow; 1370 void srand48(c_long) @nogc nothrow; 1371 ushort* seed48(ushort*) @nogc nothrow; 1372 void lcong48(ushort*) @nogc nothrow; 1373 struct drand48_data 1374 { 1375 ushort[3] __x; 1376 ushort[3] __old_x; 1377 ushort __c; 1378 ushort __init; 1379 ulong __a; 1380 } 1381 int drand48_r(drand48_data*, double*) @nogc nothrow; 1382 int erand48_r(ushort*, drand48_data*, double*) @nogc nothrow; 1383 int lrand48_r(drand48_data*, c_long*) @nogc nothrow; 1384 int nrand48_r(ushort*, drand48_data*, c_long*) @nogc nothrow; 1385 int mrand48_r(drand48_data*, c_long*) @nogc nothrow; 1386 int jrand48_r(ushort*, drand48_data*, c_long*) @nogc nothrow; 1387 int srand48_r(c_long, drand48_data*) @nogc nothrow; 1388 int seed48_r(ushort*, drand48_data*) @nogc nothrow; 1389 int lcong48_r(ushort*, drand48_data*) @nogc nothrow; 1390 void* malloc(c_ulong) @nogc nothrow; 1391 void* calloc(c_ulong, c_ulong) @nogc nothrow; 1392 void* realloc(void*, c_ulong) @nogc nothrow; 1393 void free(void*) @nogc nothrow; 1394 void* valloc(c_ulong) @nogc nothrow; 1395 int posix_memalign(void**, c_ulong, c_ulong) @nogc nothrow; 1396 void* aligned_alloc(c_ulong, c_ulong) @nogc nothrow; 1397 void abort() @nogc nothrow; 1398 int atexit(void function()) @nogc nothrow; 1399 int at_quick_exit(void function()) @nogc nothrow; 1400 int on_exit(void function(int, void*), void*) @nogc nothrow; 1401 void exit(int) @nogc nothrow; 1402 void quick_exit(int) @nogc nothrow; 1403 void _Exit(int) @nogc nothrow; 1404 char* getenv(const(char)*) @nogc nothrow; 1405 int putenv(char*) @nogc nothrow; 1406 int setenv(const(char)*, const(char)*, int) @nogc nothrow; 1407 int unsetenv(const(char)*) @nogc nothrow; 1408 int clearenv() @nogc nothrow; 1409 char* mktemp(char*) @nogc nothrow; 1410 int mkstemp(char*) @nogc nothrow; 1411 int mkstemps(char*, int) @nogc nothrow; 1412 char* mkdtemp(char*) @nogc nothrow; 1413 int system(const(char)*) @nogc nothrow; 1414 char* realpath(const(char)*, char*) @nogc nothrow; 1415 char* ecvt(double, int, int*, int*) @nogc nothrow; 1416 alias __compar_fn_t = int function(const(void)*, const(void)*); 1417 void* bsearch(const(void)*, const(void)*, c_ulong, c_ulong, int function(const(void)*, const(void)*)) @nogc nothrow; 1418 void qsort(void*, c_ulong, c_ulong, int function(const(void)*, const(void)*)) @nogc nothrow; 1419 int abs(int) @nogc nothrow; 1420 c_long labs(c_long) @nogc nothrow; 1421 long llabs(long) @nogc nothrow; 1422 div_t div(int, int) @nogc nothrow; 1423 ldiv_t ldiv(c_long, c_long) @nogc nothrow; 1424 lldiv_t lldiv(long, long) @nogc nothrow; 1425 1426 1427 1428 1429 1430 static if(!is(typeof(MB_CUR_MAX))) { 1431 private enum enumMixinStr_MB_CUR_MAX = `enum MB_CUR_MAX = ( __ctype_get_mb_cur_max ( ) );`; 1432 static if(is(typeof({ mixin(enumMixinStr_MB_CUR_MAX); }))) { 1433 mixin(enumMixinStr_MB_CUR_MAX); 1434 } 1435 } 1436 1437 1438 1439 1440 static if(!is(typeof(EXIT_SUCCESS))) { 1441 private enum enumMixinStr_EXIT_SUCCESS = `enum EXIT_SUCCESS = 0;`; 1442 static if(is(typeof({ mixin(enumMixinStr_EXIT_SUCCESS); }))) { 1443 mixin(enumMixinStr_EXIT_SUCCESS); 1444 } 1445 } 1446 1447 1448 1449 1450 static if(!is(typeof(EXIT_FAILURE))) { 1451 private enum enumMixinStr_EXIT_FAILURE = `enum EXIT_FAILURE = 1;`; 1452 static if(is(typeof({ mixin(enumMixinStr_EXIT_FAILURE); }))) { 1453 mixin(enumMixinStr_EXIT_FAILURE); 1454 } 1455 } 1456 1457 1458 1459 1460 static if(!is(typeof(RAND_MAX))) { 1461 private enum enumMixinStr_RAND_MAX = `enum RAND_MAX = 2147483647;`; 1462 static if(is(typeof({ mixin(enumMixinStr_RAND_MAX); }))) { 1463 mixin(enumMixinStr_RAND_MAX); 1464 } 1465 } 1466 1467 1468 1469 1470 static if(!is(typeof(__lldiv_t_defined))) { 1471 private enum enumMixinStr___lldiv_t_defined = `enum __lldiv_t_defined = 1;`; 1472 static if(is(typeof({ mixin(enumMixinStr___lldiv_t_defined); }))) { 1473 mixin(enumMixinStr___lldiv_t_defined); 1474 } 1475 } 1476 1477 1478 1479 1480 static if(!is(typeof(__ldiv_t_defined))) { 1481 private enum enumMixinStr___ldiv_t_defined = `enum __ldiv_t_defined = 1;`; 1482 static if(is(typeof({ mixin(enumMixinStr___ldiv_t_defined); }))) { 1483 mixin(enumMixinStr___ldiv_t_defined); 1484 } 1485 } 1486 static if(!is(typeof(_STDLIB_H))) { 1487 private enum enumMixinStr__STDLIB_H = `enum _STDLIB_H = 1;`; 1488 static if(is(typeof({ mixin(enumMixinStr__STDLIB_H); }))) { 1489 mixin(enumMixinStr__STDLIB_H); 1490 } 1491 } 1492 static if(!is(typeof(WINT_MAX))) { 1493 private enum enumMixinStr_WINT_MAX = `enum WINT_MAX = ( 4294967295u );`; 1494 static if(is(typeof({ mixin(enumMixinStr_WINT_MAX); }))) { 1495 mixin(enumMixinStr_WINT_MAX); 1496 } 1497 } 1498 1499 1500 1501 1502 static if(!is(typeof(WINT_MIN))) { 1503 private enum enumMixinStr_WINT_MIN = `enum WINT_MIN = ( 0u );`; 1504 static if(is(typeof({ mixin(enumMixinStr_WINT_MIN); }))) { 1505 mixin(enumMixinStr_WINT_MIN); 1506 } 1507 } 1508 1509 1510 1511 1512 static if(!is(typeof(WCHAR_MAX))) { 1513 private enum enumMixinStr_WCHAR_MAX = `enum WCHAR_MAX = __WCHAR_MAX;`; 1514 static if(is(typeof({ mixin(enumMixinStr_WCHAR_MAX); }))) { 1515 mixin(enumMixinStr_WCHAR_MAX); 1516 } 1517 } 1518 1519 1520 1521 1522 static if(!is(typeof(WCHAR_MIN))) { 1523 private enum enumMixinStr_WCHAR_MIN = `enum WCHAR_MIN = __WCHAR_MIN;`; 1524 static if(is(typeof({ mixin(enumMixinStr_WCHAR_MIN); }))) { 1525 mixin(enumMixinStr_WCHAR_MIN); 1526 } 1527 } 1528 1529 1530 1531 1532 static if(!is(typeof(SIZE_MAX))) { 1533 private enum enumMixinStr_SIZE_MAX = `enum SIZE_MAX = ( 18446744073709551615UL );`; 1534 static if(is(typeof({ mixin(enumMixinStr_SIZE_MAX); }))) { 1535 mixin(enumMixinStr_SIZE_MAX); 1536 } 1537 } 1538 1539 1540 1541 1542 static if(!is(typeof(SIG_ATOMIC_MAX))) { 1543 private enum enumMixinStr_SIG_ATOMIC_MAX = `enum SIG_ATOMIC_MAX = ( 2147483647 );`; 1544 static if(is(typeof({ mixin(enumMixinStr_SIG_ATOMIC_MAX); }))) { 1545 mixin(enumMixinStr_SIG_ATOMIC_MAX); 1546 } 1547 } 1548 1549 1550 1551 1552 static if(!is(typeof(SIG_ATOMIC_MIN))) { 1553 private enum enumMixinStr_SIG_ATOMIC_MIN = `enum SIG_ATOMIC_MIN = ( - 2147483647 - 1 );`; 1554 static if(is(typeof({ mixin(enumMixinStr_SIG_ATOMIC_MIN); }))) { 1555 mixin(enumMixinStr_SIG_ATOMIC_MIN); 1556 } 1557 } 1558 1559 1560 1561 1562 static if(!is(typeof(PTRDIFF_MAX))) { 1563 private enum enumMixinStr_PTRDIFF_MAX = `enum PTRDIFF_MAX = ( 9223372036854775807L );`; 1564 static if(is(typeof({ mixin(enumMixinStr_PTRDIFF_MAX); }))) { 1565 mixin(enumMixinStr_PTRDIFF_MAX); 1566 } 1567 } 1568 1569 1570 1571 1572 static if(!is(typeof(PTRDIFF_MIN))) { 1573 private enum enumMixinStr_PTRDIFF_MIN = `enum PTRDIFF_MIN = ( - 9223372036854775807L - 1 );`; 1574 static if(is(typeof({ mixin(enumMixinStr_PTRDIFF_MIN); }))) { 1575 mixin(enumMixinStr_PTRDIFF_MIN); 1576 } 1577 } 1578 1579 1580 1581 1582 static if(!is(typeof(UINTMAX_MAX))) { 1583 private enum enumMixinStr_UINTMAX_MAX = `enum UINTMAX_MAX = ( 18446744073709551615UL );`; 1584 static if(is(typeof({ mixin(enumMixinStr_UINTMAX_MAX); }))) { 1585 mixin(enumMixinStr_UINTMAX_MAX); 1586 } 1587 } 1588 1589 1590 1591 1592 static if(!is(typeof(INTMAX_MAX))) { 1593 private enum enumMixinStr_INTMAX_MAX = `enum INTMAX_MAX = ( 9223372036854775807L );`; 1594 static if(is(typeof({ mixin(enumMixinStr_INTMAX_MAX); }))) { 1595 mixin(enumMixinStr_INTMAX_MAX); 1596 } 1597 } 1598 1599 1600 1601 1602 static if(!is(typeof(INTMAX_MIN))) { 1603 private enum enumMixinStr_INTMAX_MIN = `enum INTMAX_MIN = ( - 9223372036854775807L - 1 );`; 1604 static if(is(typeof({ mixin(enumMixinStr_INTMAX_MIN); }))) { 1605 mixin(enumMixinStr_INTMAX_MIN); 1606 } 1607 } 1608 1609 1610 1611 1612 static if(!is(typeof(UINTPTR_MAX))) { 1613 private enum enumMixinStr_UINTPTR_MAX = `enum UINTPTR_MAX = ( 18446744073709551615UL );`; 1614 static if(is(typeof({ mixin(enumMixinStr_UINTPTR_MAX); }))) { 1615 mixin(enumMixinStr_UINTPTR_MAX); 1616 } 1617 } 1618 1619 1620 1621 1622 static if(!is(typeof(INTPTR_MAX))) { 1623 private enum enumMixinStr_INTPTR_MAX = `enum INTPTR_MAX = ( 9223372036854775807L );`; 1624 static if(is(typeof({ mixin(enumMixinStr_INTPTR_MAX); }))) { 1625 mixin(enumMixinStr_INTPTR_MAX); 1626 } 1627 } 1628 1629 1630 1631 1632 static if(!is(typeof(INTPTR_MIN))) { 1633 private enum enumMixinStr_INTPTR_MIN = `enum INTPTR_MIN = ( - 9223372036854775807L - 1 );`; 1634 static if(is(typeof({ mixin(enumMixinStr_INTPTR_MIN); }))) { 1635 mixin(enumMixinStr_INTPTR_MIN); 1636 } 1637 } 1638 1639 1640 1641 1642 static if(!is(typeof(UINT_FAST64_MAX))) { 1643 private enum enumMixinStr_UINT_FAST64_MAX = `enum UINT_FAST64_MAX = ( 18446744073709551615UL );`; 1644 static if(is(typeof({ mixin(enumMixinStr_UINT_FAST64_MAX); }))) { 1645 mixin(enumMixinStr_UINT_FAST64_MAX); 1646 } 1647 } 1648 1649 1650 1651 1652 static if(!is(typeof(UINT_FAST32_MAX))) { 1653 private enum enumMixinStr_UINT_FAST32_MAX = `enum UINT_FAST32_MAX = ( 18446744073709551615UL );`; 1654 static if(is(typeof({ mixin(enumMixinStr_UINT_FAST32_MAX); }))) { 1655 mixin(enumMixinStr_UINT_FAST32_MAX); 1656 } 1657 } 1658 1659 1660 1661 1662 static if(!is(typeof(UINT_FAST16_MAX))) { 1663 private enum enumMixinStr_UINT_FAST16_MAX = `enum UINT_FAST16_MAX = ( 18446744073709551615UL );`; 1664 static if(is(typeof({ mixin(enumMixinStr_UINT_FAST16_MAX); }))) { 1665 mixin(enumMixinStr_UINT_FAST16_MAX); 1666 } 1667 } 1668 1669 1670 1671 1672 static if(!is(typeof(UINT_FAST8_MAX))) { 1673 private enum enumMixinStr_UINT_FAST8_MAX = `enum UINT_FAST8_MAX = ( 255 );`; 1674 static if(is(typeof({ mixin(enumMixinStr_UINT_FAST8_MAX); }))) { 1675 mixin(enumMixinStr_UINT_FAST8_MAX); 1676 } 1677 } 1678 1679 1680 1681 1682 static if(!is(typeof(INT_FAST64_MAX))) { 1683 private enum enumMixinStr_INT_FAST64_MAX = `enum INT_FAST64_MAX = ( 9223372036854775807L );`; 1684 static if(is(typeof({ mixin(enumMixinStr_INT_FAST64_MAX); }))) { 1685 mixin(enumMixinStr_INT_FAST64_MAX); 1686 } 1687 } 1688 1689 1690 1691 1692 static if(!is(typeof(INT_FAST32_MAX))) { 1693 private enum enumMixinStr_INT_FAST32_MAX = `enum INT_FAST32_MAX = ( 9223372036854775807L );`; 1694 static if(is(typeof({ mixin(enumMixinStr_INT_FAST32_MAX); }))) { 1695 mixin(enumMixinStr_INT_FAST32_MAX); 1696 } 1697 } 1698 1699 1700 1701 1702 static if(!is(typeof(INT_FAST16_MAX))) { 1703 private enum enumMixinStr_INT_FAST16_MAX = `enum INT_FAST16_MAX = ( 9223372036854775807L );`; 1704 static if(is(typeof({ mixin(enumMixinStr_INT_FAST16_MAX); }))) { 1705 mixin(enumMixinStr_INT_FAST16_MAX); 1706 } 1707 } 1708 1709 1710 1711 1712 static if(!is(typeof(INT_FAST8_MAX))) { 1713 private enum enumMixinStr_INT_FAST8_MAX = `enum INT_FAST8_MAX = ( 127 );`; 1714 static if(is(typeof({ mixin(enumMixinStr_INT_FAST8_MAX); }))) { 1715 mixin(enumMixinStr_INT_FAST8_MAX); 1716 } 1717 } 1718 1719 1720 1721 1722 static if(!is(typeof(INT_FAST64_MIN))) { 1723 private enum enumMixinStr_INT_FAST64_MIN = `enum INT_FAST64_MIN = ( - 9223372036854775807L - 1 );`; 1724 static if(is(typeof({ mixin(enumMixinStr_INT_FAST64_MIN); }))) { 1725 mixin(enumMixinStr_INT_FAST64_MIN); 1726 } 1727 } 1728 1729 1730 1731 1732 static if(!is(typeof(INT_FAST32_MIN))) { 1733 private enum enumMixinStr_INT_FAST32_MIN = `enum INT_FAST32_MIN = ( - 9223372036854775807L - 1 );`; 1734 static if(is(typeof({ mixin(enumMixinStr_INT_FAST32_MIN); }))) { 1735 mixin(enumMixinStr_INT_FAST32_MIN); 1736 } 1737 } 1738 1739 1740 1741 1742 static if(!is(typeof(INT_FAST16_MIN))) { 1743 private enum enumMixinStr_INT_FAST16_MIN = `enum INT_FAST16_MIN = ( - 9223372036854775807L - 1 );`; 1744 static if(is(typeof({ mixin(enumMixinStr_INT_FAST16_MIN); }))) { 1745 mixin(enumMixinStr_INT_FAST16_MIN); 1746 } 1747 } 1748 1749 1750 1751 1752 static if(!is(typeof(INT_FAST8_MIN))) { 1753 private enum enumMixinStr_INT_FAST8_MIN = `enum INT_FAST8_MIN = ( - 128 );`; 1754 static if(is(typeof({ mixin(enumMixinStr_INT_FAST8_MIN); }))) { 1755 mixin(enumMixinStr_INT_FAST8_MIN); 1756 } 1757 } 1758 1759 1760 1761 1762 static if(!is(typeof(UINT_LEAST64_MAX))) { 1763 private enum enumMixinStr_UINT_LEAST64_MAX = `enum UINT_LEAST64_MAX = ( 18446744073709551615UL );`; 1764 static if(is(typeof({ mixin(enumMixinStr_UINT_LEAST64_MAX); }))) { 1765 mixin(enumMixinStr_UINT_LEAST64_MAX); 1766 } 1767 } 1768 1769 1770 1771 1772 static if(!is(typeof(UINT_LEAST32_MAX))) { 1773 private enum enumMixinStr_UINT_LEAST32_MAX = `enum UINT_LEAST32_MAX = ( 4294967295U );`; 1774 static if(is(typeof({ mixin(enumMixinStr_UINT_LEAST32_MAX); }))) { 1775 mixin(enumMixinStr_UINT_LEAST32_MAX); 1776 } 1777 } 1778 1779 1780 1781 1782 static if(!is(typeof(UINT_LEAST16_MAX))) { 1783 private enum enumMixinStr_UINT_LEAST16_MAX = `enum UINT_LEAST16_MAX = ( 65535 );`; 1784 static if(is(typeof({ mixin(enumMixinStr_UINT_LEAST16_MAX); }))) { 1785 mixin(enumMixinStr_UINT_LEAST16_MAX); 1786 } 1787 } 1788 1789 1790 1791 1792 static if(!is(typeof(UINT_LEAST8_MAX))) { 1793 private enum enumMixinStr_UINT_LEAST8_MAX = `enum UINT_LEAST8_MAX = ( 255 );`; 1794 static if(is(typeof({ mixin(enumMixinStr_UINT_LEAST8_MAX); }))) { 1795 mixin(enumMixinStr_UINT_LEAST8_MAX); 1796 } 1797 } 1798 1799 1800 1801 1802 static if(!is(typeof(INT_LEAST64_MAX))) { 1803 private enum enumMixinStr_INT_LEAST64_MAX = `enum INT_LEAST64_MAX = ( 9223372036854775807L );`; 1804 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST64_MAX); }))) { 1805 mixin(enumMixinStr_INT_LEAST64_MAX); 1806 } 1807 } 1808 1809 1810 1811 1812 static if(!is(typeof(INT_LEAST32_MAX))) { 1813 private enum enumMixinStr_INT_LEAST32_MAX = `enum INT_LEAST32_MAX = ( 2147483647 );`; 1814 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST32_MAX); }))) { 1815 mixin(enumMixinStr_INT_LEAST32_MAX); 1816 } 1817 } 1818 1819 1820 1821 1822 static if(!is(typeof(INT_LEAST16_MAX))) { 1823 private enum enumMixinStr_INT_LEAST16_MAX = `enum INT_LEAST16_MAX = ( 32767 );`; 1824 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST16_MAX); }))) { 1825 mixin(enumMixinStr_INT_LEAST16_MAX); 1826 } 1827 } 1828 1829 1830 1831 1832 static if(!is(typeof(INT_LEAST8_MAX))) { 1833 private enum enumMixinStr_INT_LEAST8_MAX = `enum INT_LEAST8_MAX = ( 127 );`; 1834 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST8_MAX); }))) { 1835 mixin(enumMixinStr_INT_LEAST8_MAX); 1836 } 1837 } 1838 1839 1840 1841 1842 static if(!is(typeof(INT_LEAST64_MIN))) { 1843 private enum enumMixinStr_INT_LEAST64_MIN = `enum INT_LEAST64_MIN = ( - 9223372036854775807L - 1 );`; 1844 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST64_MIN); }))) { 1845 mixin(enumMixinStr_INT_LEAST64_MIN); 1846 } 1847 } 1848 1849 1850 1851 1852 static if(!is(typeof(INT_LEAST32_MIN))) { 1853 private enum enumMixinStr_INT_LEAST32_MIN = `enum INT_LEAST32_MIN = ( - 2147483647 - 1 );`; 1854 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST32_MIN); }))) { 1855 mixin(enumMixinStr_INT_LEAST32_MIN); 1856 } 1857 } 1858 1859 1860 1861 1862 static if(!is(typeof(INT_LEAST16_MIN))) { 1863 private enum enumMixinStr_INT_LEAST16_MIN = `enum INT_LEAST16_MIN = ( - 32767 - 1 );`; 1864 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST16_MIN); }))) { 1865 mixin(enumMixinStr_INT_LEAST16_MIN); 1866 } 1867 } 1868 1869 1870 1871 1872 static if(!is(typeof(INT_LEAST8_MIN))) { 1873 private enum enumMixinStr_INT_LEAST8_MIN = `enum INT_LEAST8_MIN = ( - 128 );`; 1874 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST8_MIN); }))) { 1875 mixin(enumMixinStr_INT_LEAST8_MIN); 1876 } 1877 } 1878 1879 1880 1881 1882 static if(!is(typeof(UINT64_MAX))) { 1883 private enum enumMixinStr_UINT64_MAX = `enum UINT64_MAX = ( 18446744073709551615UL );`; 1884 static if(is(typeof({ mixin(enumMixinStr_UINT64_MAX); }))) { 1885 mixin(enumMixinStr_UINT64_MAX); 1886 } 1887 } 1888 1889 1890 1891 1892 1893 1894 static if(!is(typeof(UINT32_MAX))) { 1895 private enum enumMixinStr_UINT32_MAX = `enum UINT32_MAX = ( 4294967295U );`; 1896 static if(is(typeof({ mixin(enumMixinStr_UINT32_MAX); }))) { 1897 mixin(enumMixinStr_UINT32_MAX); 1898 } 1899 } 1900 1901 1902 1903 1904 static if(!is(typeof(_BITS_BYTESWAP_H))) { 1905 private enum enumMixinStr__BITS_BYTESWAP_H = `enum _BITS_BYTESWAP_H = 1;`; 1906 static if(is(typeof({ mixin(enumMixinStr__BITS_BYTESWAP_H); }))) { 1907 mixin(enumMixinStr__BITS_BYTESWAP_H); 1908 } 1909 } 1910 1911 1912 1913 1914 static if(!is(typeof(UINT16_MAX))) { 1915 private enum enumMixinStr_UINT16_MAX = `enum UINT16_MAX = ( 65535 );`; 1916 static if(is(typeof({ mixin(enumMixinStr_UINT16_MAX); }))) { 1917 mixin(enumMixinStr_UINT16_MAX); 1918 } 1919 } 1920 1921 1922 1923 1924 static if(!is(typeof(UINT8_MAX))) { 1925 private enum enumMixinStr_UINT8_MAX = `enum UINT8_MAX = ( 255 );`; 1926 static if(is(typeof({ mixin(enumMixinStr_UINT8_MAX); }))) { 1927 mixin(enumMixinStr_UINT8_MAX); 1928 } 1929 } 1930 1931 1932 1933 1934 static if(!is(typeof(INT64_MAX))) { 1935 private enum enumMixinStr_INT64_MAX = `enum INT64_MAX = ( 9223372036854775807L );`; 1936 static if(is(typeof({ mixin(enumMixinStr_INT64_MAX); }))) { 1937 mixin(enumMixinStr_INT64_MAX); 1938 } 1939 } 1940 1941 1942 1943 1944 1945 1946 static if(!is(typeof(INT32_MAX))) { 1947 private enum enumMixinStr_INT32_MAX = `enum INT32_MAX = ( 2147483647 );`; 1948 static if(is(typeof({ mixin(enumMixinStr_INT32_MAX); }))) { 1949 mixin(enumMixinStr_INT32_MAX); 1950 } 1951 } 1952 1953 1954 1955 1956 1957 1958 static if(!is(typeof(INT16_MAX))) { 1959 private enum enumMixinStr_INT16_MAX = `enum INT16_MAX = ( 32767 );`; 1960 static if(is(typeof({ mixin(enumMixinStr_INT16_MAX); }))) { 1961 mixin(enumMixinStr_INT16_MAX); 1962 } 1963 } 1964 1965 1966 1967 1968 static if(!is(typeof(INT8_MAX))) { 1969 private enum enumMixinStr_INT8_MAX = `enum INT8_MAX = ( 127 );`; 1970 static if(is(typeof({ mixin(enumMixinStr_INT8_MAX); }))) { 1971 mixin(enumMixinStr_INT8_MAX); 1972 } 1973 } 1974 1975 1976 1977 1978 static if(!is(typeof(INT64_MIN))) { 1979 private enum enumMixinStr_INT64_MIN = `enum INT64_MIN = ( - 9223372036854775807L - 1 );`; 1980 static if(is(typeof({ mixin(enumMixinStr_INT64_MIN); }))) { 1981 mixin(enumMixinStr_INT64_MIN); 1982 } 1983 } 1984 1985 1986 1987 1988 static if(!is(typeof(INT32_MIN))) { 1989 private enum enumMixinStr_INT32_MIN = `enum INT32_MIN = ( - 2147483647 - 1 );`; 1990 static if(is(typeof({ mixin(enumMixinStr_INT32_MIN); }))) { 1991 mixin(enumMixinStr_INT32_MIN); 1992 } 1993 } 1994 1995 1996 1997 1998 static if(!is(typeof(INT16_MIN))) { 1999 private enum enumMixinStr_INT16_MIN = `enum INT16_MIN = ( - 32767 - 1 );`; 2000 static if(is(typeof({ mixin(enumMixinStr_INT16_MIN); }))) { 2001 mixin(enumMixinStr_INT16_MIN); 2002 } 2003 } 2004 2005 2006 2007 2008 2009 2010 static if(!is(typeof(INT8_MIN))) { 2011 private enum enumMixinStr_INT8_MIN = `enum INT8_MIN = ( - 128 );`; 2012 static if(is(typeof({ mixin(enumMixinStr_INT8_MIN); }))) { 2013 mixin(enumMixinStr_INT8_MIN); 2014 } 2015 } 2016 static if(!is(typeof(__BYTE_ORDER))) { 2017 private enum enumMixinStr___BYTE_ORDER = `enum __BYTE_ORDER = __LITTLE_ENDIAN;`; 2018 static if(is(typeof({ mixin(enumMixinStr___BYTE_ORDER); }))) { 2019 mixin(enumMixinStr___BYTE_ORDER); 2020 } 2021 } 2022 2023 2024 2025 2026 2027 2028 static if(!is(typeof(_STDINT_H))) { 2029 private enum enumMixinStr__STDINT_H = `enum _STDINT_H = 1;`; 2030 static if(is(typeof({ mixin(enumMixinStr__STDINT_H); }))) { 2031 mixin(enumMixinStr__STDINT_H); 2032 } 2033 } 2034 2035 2036 2037 2038 static if(!is(typeof(__HAVE_FLOAT16))) { 2039 private enum enumMixinStr___HAVE_FLOAT16 = `enum __HAVE_FLOAT16 = 0;`; 2040 static if(is(typeof({ mixin(enumMixinStr___HAVE_FLOAT16); }))) { 2041 mixin(enumMixinStr___HAVE_FLOAT16); 2042 } 2043 } 2044 2045 2046 2047 2048 static if(!is(typeof(__HAVE_FLOAT32))) { 2049 private enum enumMixinStr___HAVE_FLOAT32 = `enum __HAVE_FLOAT32 = 1;`; 2050 static if(is(typeof({ mixin(enumMixinStr___HAVE_FLOAT32); }))) { 2051 mixin(enumMixinStr___HAVE_FLOAT32); 2052 } 2053 } 2054 2055 2056 2057 2058 static if(!is(typeof(__HAVE_FLOAT64))) { 2059 private enum enumMixinStr___HAVE_FLOAT64 = `enum __HAVE_FLOAT64 = 1;`; 2060 static if(is(typeof({ mixin(enumMixinStr___HAVE_FLOAT64); }))) { 2061 mixin(enumMixinStr___HAVE_FLOAT64); 2062 } 2063 } 2064 2065 2066 2067 2068 static if(!is(typeof(__HAVE_FLOAT32X))) { 2069 private enum enumMixinStr___HAVE_FLOAT32X = `enum __HAVE_FLOAT32X = 1;`; 2070 static if(is(typeof({ mixin(enumMixinStr___HAVE_FLOAT32X); }))) { 2071 mixin(enumMixinStr___HAVE_FLOAT32X); 2072 } 2073 } 2074 2075 2076 2077 2078 static if(!is(typeof(__HAVE_FLOAT128X))) { 2079 private enum enumMixinStr___HAVE_FLOAT128X = `enum __HAVE_FLOAT128X = 0;`; 2080 static if(is(typeof({ mixin(enumMixinStr___HAVE_FLOAT128X); }))) { 2081 mixin(enumMixinStr___HAVE_FLOAT128X); 2082 } 2083 } 2084 2085 2086 2087 2088 static if(!is(typeof(__HAVE_DISTINCT_FLOAT16))) { 2089 private enum enumMixinStr___HAVE_DISTINCT_FLOAT16 = `enum __HAVE_DISTINCT_FLOAT16 = 0;`; 2090 static if(is(typeof({ mixin(enumMixinStr___HAVE_DISTINCT_FLOAT16); }))) { 2091 mixin(enumMixinStr___HAVE_DISTINCT_FLOAT16); 2092 } 2093 } 2094 2095 2096 2097 2098 static if(!is(typeof(__HAVE_DISTINCT_FLOAT32))) { 2099 private enum enumMixinStr___HAVE_DISTINCT_FLOAT32 = `enum __HAVE_DISTINCT_FLOAT32 = 0;`; 2100 static if(is(typeof({ mixin(enumMixinStr___HAVE_DISTINCT_FLOAT32); }))) { 2101 mixin(enumMixinStr___HAVE_DISTINCT_FLOAT32); 2102 } 2103 } 2104 2105 2106 2107 2108 static if(!is(typeof(__HAVE_DISTINCT_FLOAT64))) { 2109 private enum enumMixinStr___HAVE_DISTINCT_FLOAT64 = `enum __HAVE_DISTINCT_FLOAT64 = 0;`; 2110 static if(is(typeof({ mixin(enumMixinStr___HAVE_DISTINCT_FLOAT64); }))) { 2111 mixin(enumMixinStr___HAVE_DISTINCT_FLOAT64); 2112 } 2113 } 2114 2115 2116 2117 2118 static if(!is(typeof(__HAVE_DISTINCT_FLOAT32X))) { 2119 private enum enumMixinStr___HAVE_DISTINCT_FLOAT32X = `enum __HAVE_DISTINCT_FLOAT32X = 0;`; 2120 static if(is(typeof({ mixin(enumMixinStr___HAVE_DISTINCT_FLOAT32X); }))) { 2121 mixin(enumMixinStr___HAVE_DISTINCT_FLOAT32X); 2122 } 2123 } 2124 2125 2126 2127 2128 static if(!is(typeof(__HAVE_DISTINCT_FLOAT64X))) { 2129 private enum enumMixinStr___HAVE_DISTINCT_FLOAT64X = `enum __HAVE_DISTINCT_FLOAT64X = 0;`; 2130 static if(is(typeof({ mixin(enumMixinStr___HAVE_DISTINCT_FLOAT64X); }))) { 2131 mixin(enumMixinStr___HAVE_DISTINCT_FLOAT64X); 2132 } 2133 } 2134 2135 2136 2137 2138 static if(!is(typeof(__HAVE_DISTINCT_FLOAT128X))) { 2139 private enum enumMixinStr___HAVE_DISTINCT_FLOAT128X = `enum __HAVE_DISTINCT_FLOAT128X = 0;`; 2140 static if(is(typeof({ mixin(enumMixinStr___HAVE_DISTINCT_FLOAT128X); }))) { 2141 mixin(enumMixinStr___HAVE_DISTINCT_FLOAT128X); 2142 } 2143 } 2144 2145 2146 2147 2148 static if(!is(typeof(__HAVE_FLOATN_NOT_TYPEDEF))) { 2149 private enum enumMixinStr___HAVE_FLOATN_NOT_TYPEDEF = `enum __HAVE_FLOATN_NOT_TYPEDEF = 0;`; 2150 static if(is(typeof({ mixin(enumMixinStr___HAVE_FLOATN_NOT_TYPEDEF); }))) { 2151 mixin(enumMixinStr___HAVE_FLOATN_NOT_TYPEDEF); 2152 } 2153 } 2154 2155 2156 2157 2158 2159 2160 static if(!is(typeof(_STDC_PREDEF_H))) { 2161 private enum enumMixinStr__STDC_PREDEF_H = `enum _STDC_PREDEF_H = 1;`; 2162 static if(is(typeof({ mixin(enumMixinStr__STDC_PREDEF_H); }))) { 2163 mixin(enumMixinStr__STDC_PREDEF_H); 2164 } 2165 } 2166 static if(!is(typeof(__GLIBC_MINOR__))) { 2167 private enum enumMixinStr___GLIBC_MINOR__ = `enum __GLIBC_MINOR__ = 27;`; 2168 static if(is(typeof({ mixin(enumMixinStr___GLIBC_MINOR__); }))) { 2169 mixin(enumMixinStr___GLIBC_MINOR__); 2170 } 2171 } 2172 2173 2174 2175 2176 static if(!is(typeof(__GLIBC__))) { 2177 private enum enumMixinStr___GLIBC__ = `enum __GLIBC__ = 2;`; 2178 static if(is(typeof({ mixin(enumMixinStr___GLIBC__); }))) { 2179 mixin(enumMixinStr___GLIBC__); 2180 } 2181 } 2182 2183 2184 2185 2186 2187 2188 static if(!is(typeof(__GNU_LIBRARY__))) { 2189 private enum enumMixinStr___GNU_LIBRARY__ = `enum __GNU_LIBRARY__ = 6;`; 2190 static if(is(typeof({ mixin(enumMixinStr___GNU_LIBRARY__); }))) { 2191 mixin(enumMixinStr___GNU_LIBRARY__); 2192 } 2193 } 2194 2195 2196 2197 2198 static if(!is(typeof(__GLIBC_USE_DEPRECATED_GETS))) { 2199 private enum enumMixinStr___GLIBC_USE_DEPRECATED_GETS = `enum __GLIBC_USE_DEPRECATED_GETS = 0;`; 2200 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_DEPRECATED_GETS); }))) { 2201 mixin(enumMixinStr___GLIBC_USE_DEPRECATED_GETS); 2202 } 2203 } 2204 2205 2206 2207 2208 static if(!is(typeof(__USE_FORTIFY_LEVEL))) { 2209 private enum enumMixinStr___USE_FORTIFY_LEVEL = `enum __USE_FORTIFY_LEVEL = 0;`; 2210 static if(is(typeof({ mixin(enumMixinStr___USE_FORTIFY_LEVEL); }))) { 2211 mixin(enumMixinStr___USE_FORTIFY_LEVEL); 2212 } 2213 } 2214 2215 2216 2217 2218 2219 2220 static if(!is(typeof(__USE_ATFILE))) { 2221 private enum enumMixinStr___USE_ATFILE = `enum __USE_ATFILE = 1;`; 2222 static if(is(typeof({ mixin(enumMixinStr___USE_ATFILE); }))) { 2223 mixin(enumMixinStr___USE_ATFILE); 2224 } 2225 } 2226 2227 2228 2229 2230 static if(!is(typeof(__USE_MISC))) { 2231 private enum enumMixinStr___USE_MISC = `enum __USE_MISC = 1;`; 2232 static if(is(typeof({ mixin(enumMixinStr___USE_MISC); }))) { 2233 mixin(enumMixinStr___USE_MISC); 2234 } 2235 } 2236 2237 2238 2239 2240 static if(!is(typeof(_ATFILE_SOURCE))) { 2241 private enum enumMixinStr__ATFILE_SOURCE = `enum _ATFILE_SOURCE = 1;`; 2242 static if(is(typeof({ mixin(enumMixinStr__ATFILE_SOURCE); }))) { 2243 mixin(enumMixinStr__ATFILE_SOURCE); 2244 } 2245 } 2246 2247 2248 2249 2250 static if(!is(typeof(__USE_XOPEN2K8))) { 2251 private enum enumMixinStr___USE_XOPEN2K8 = `enum __USE_XOPEN2K8 = 1;`; 2252 static if(is(typeof({ mixin(enumMixinStr___USE_XOPEN2K8); }))) { 2253 mixin(enumMixinStr___USE_XOPEN2K8); 2254 } 2255 } 2256 2257 2258 2259 2260 static if(!is(typeof(__CFLOAT32))) { 2261 private enum enumMixinStr___CFLOAT32 = `enum __CFLOAT32 = _Complex float;`; 2262 static if(is(typeof({ mixin(enumMixinStr___CFLOAT32); }))) { 2263 mixin(enumMixinStr___CFLOAT32); 2264 } 2265 } 2266 2267 2268 2269 2270 static if(!is(typeof(__USE_ISOC99))) { 2271 private enum enumMixinStr___USE_ISOC99 = `enum __USE_ISOC99 = 1;`; 2272 static if(is(typeof({ mixin(enumMixinStr___USE_ISOC99); }))) { 2273 mixin(enumMixinStr___USE_ISOC99); 2274 } 2275 } 2276 2277 2278 2279 2280 static if(!is(typeof(__USE_ISOC95))) { 2281 private enum enumMixinStr___USE_ISOC95 = `enum __USE_ISOC95 = 1;`; 2282 static if(is(typeof({ mixin(enumMixinStr___USE_ISOC95); }))) { 2283 mixin(enumMixinStr___USE_ISOC95); 2284 } 2285 } 2286 2287 2288 2289 2290 static if(!is(typeof(__CFLOAT64))) { 2291 private enum enumMixinStr___CFLOAT64 = `enum __CFLOAT64 = _Complex double;`; 2292 static if(is(typeof({ mixin(enumMixinStr___CFLOAT64); }))) { 2293 mixin(enumMixinStr___CFLOAT64); 2294 } 2295 } 2296 2297 2298 2299 2300 static if(!is(typeof(__USE_XOPEN2K))) { 2301 private enum enumMixinStr___USE_XOPEN2K = `enum __USE_XOPEN2K = 1;`; 2302 static if(is(typeof({ mixin(enumMixinStr___USE_XOPEN2K); }))) { 2303 mixin(enumMixinStr___USE_XOPEN2K); 2304 } 2305 } 2306 2307 2308 2309 2310 static if(!is(typeof(__USE_POSIX199506))) { 2311 private enum enumMixinStr___USE_POSIX199506 = `enum __USE_POSIX199506 = 1;`; 2312 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX199506); }))) { 2313 mixin(enumMixinStr___USE_POSIX199506); 2314 } 2315 } 2316 2317 2318 2319 2320 static if(!is(typeof(__CFLOAT32X))) { 2321 private enum enumMixinStr___CFLOAT32X = `enum __CFLOAT32X = _Complex double;`; 2322 static if(is(typeof({ mixin(enumMixinStr___CFLOAT32X); }))) { 2323 mixin(enumMixinStr___CFLOAT32X); 2324 } 2325 } 2326 2327 2328 2329 2330 static if(!is(typeof(__USE_POSIX199309))) { 2331 private enum enumMixinStr___USE_POSIX199309 = `enum __USE_POSIX199309 = 1;`; 2332 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX199309); }))) { 2333 mixin(enumMixinStr___USE_POSIX199309); 2334 } 2335 } 2336 2337 2338 2339 2340 static if(!is(typeof(__USE_POSIX2))) { 2341 private enum enumMixinStr___USE_POSIX2 = `enum __USE_POSIX2 = 1;`; 2342 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX2); }))) { 2343 mixin(enumMixinStr___USE_POSIX2); 2344 } 2345 } 2346 2347 2348 2349 2350 static if(!is(typeof(__USE_POSIX))) { 2351 private enum enumMixinStr___USE_POSIX = `enum __USE_POSIX = 1;`; 2352 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX); }))) { 2353 mixin(enumMixinStr___USE_POSIX); 2354 } 2355 } 2356 2357 2358 2359 2360 static if(!is(typeof(__CFLOAT64X))) { 2361 private enum enumMixinStr___CFLOAT64X = `enum __CFLOAT64X = _Complex long double;`; 2362 static if(is(typeof({ mixin(enumMixinStr___CFLOAT64X); }))) { 2363 mixin(enumMixinStr___CFLOAT64X); 2364 } 2365 } 2366 2367 2368 2369 2370 static if(!is(typeof(_POSIX_C_SOURCE))) { 2371 private enum enumMixinStr__POSIX_C_SOURCE = `enum _POSIX_C_SOURCE = 200809L;`; 2372 static if(is(typeof({ mixin(enumMixinStr__POSIX_C_SOURCE); }))) { 2373 mixin(enumMixinStr__POSIX_C_SOURCE); 2374 } 2375 } 2376 2377 2378 2379 2380 static if(!is(typeof(_POSIX_SOURCE))) { 2381 private enum enumMixinStr__POSIX_SOURCE = `enum _POSIX_SOURCE = 1;`; 2382 static if(is(typeof({ mixin(enumMixinStr__POSIX_SOURCE); }))) { 2383 mixin(enumMixinStr__POSIX_SOURCE); 2384 } 2385 } 2386 2387 2388 2389 2390 static if(!is(typeof(__USE_POSIX_IMPLICITLY))) { 2391 private enum enumMixinStr___USE_POSIX_IMPLICITLY = `enum __USE_POSIX_IMPLICITLY = 1;`; 2392 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX_IMPLICITLY); }))) { 2393 mixin(enumMixinStr___USE_POSIX_IMPLICITLY); 2394 } 2395 } 2396 2397 2398 2399 2400 static if(!is(typeof(__USE_ISOC11))) { 2401 private enum enumMixinStr___USE_ISOC11 = `enum __USE_ISOC11 = 1;`; 2402 static if(is(typeof({ mixin(enumMixinStr___USE_ISOC11); }))) { 2403 mixin(enumMixinStr___USE_ISOC11); 2404 } 2405 } 2406 static if(!is(typeof(_DEFAULT_SOURCE))) { 2407 private enum enumMixinStr__DEFAULT_SOURCE = `enum _DEFAULT_SOURCE = 1;`; 2408 static if(is(typeof({ mixin(enumMixinStr__DEFAULT_SOURCE); }))) { 2409 mixin(enumMixinStr__DEFAULT_SOURCE); 2410 } 2411 } 2412 static if(!is(typeof(_FEATURES_H))) { 2413 private enum enumMixinStr__FEATURES_H = `enum _FEATURES_H = 1;`; 2414 static if(is(typeof({ mixin(enumMixinStr__FEATURES_H); }))) { 2415 mixin(enumMixinStr__FEATURES_H); 2416 } 2417 } 2418 static if(!is(typeof(__HAVE_FLOAT128))) { 2419 private enum enumMixinStr___HAVE_FLOAT128 = `enum __HAVE_FLOAT128 = 0;`; 2420 static if(is(typeof({ mixin(enumMixinStr___HAVE_FLOAT128); }))) { 2421 mixin(enumMixinStr___HAVE_FLOAT128); 2422 } 2423 } 2424 2425 2426 2427 2428 static if(!is(typeof(BYTE_ORDER))) { 2429 private enum enumMixinStr_BYTE_ORDER = `enum BYTE_ORDER = __LITTLE_ENDIAN;`; 2430 static if(is(typeof({ mixin(enumMixinStr_BYTE_ORDER); }))) { 2431 mixin(enumMixinStr_BYTE_ORDER); 2432 } 2433 } 2434 2435 2436 2437 2438 static if(!is(typeof(__HAVE_DISTINCT_FLOAT128))) { 2439 private enum enumMixinStr___HAVE_DISTINCT_FLOAT128 = `enum __HAVE_DISTINCT_FLOAT128 = 0;`; 2440 static if(is(typeof({ mixin(enumMixinStr___HAVE_DISTINCT_FLOAT128); }))) { 2441 mixin(enumMixinStr___HAVE_DISTINCT_FLOAT128); 2442 } 2443 } 2444 2445 2446 2447 2448 static if(!is(typeof(__HAVE_FLOAT64X))) { 2449 private enum enumMixinStr___HAVE_FLOAT64X = `enum __HAVE_FLOAT64X = 1;`; 2450 static if(is(typeof({ mixin(enumMixinStr___HAVE_FLOAT64X); }))) { 2451 mixin(enumMixinStr___HAVE_FLOAT64X); 2452 } 2453 } 2454 2455 2456 2457 2458 static if(!is(typeof(__HAVE_FLOAT64X_LONG_DOUBLE))) { 2459 private enum enumMixinStr___HAVE_FLOAT64X_LONG_DOUBLE = `enum __HAVE_FLOAT64X_LONG_DOUBLE = 1;`; 2460 static if(is(typeof({ mixin(enumMixinStr___HAVE_FLOAT64X_LONG_DOUBLE); }))) { 2461 mixin(enumMixinStr___HAVE_FLOAT64X_LONG_DOUBLE); 2462 } 2463 } 2464 2465 2466 2467 2468 static if(!is(typeof(PDP_ENDIAN))) { 2469 private enum enumMixinStr_PDP_ENDIAN = `enum PDP_ENDIAN = __PDP_ENDIAN;`; 2470 static if(is(typeof({ mixin(enumMixinStr_PDP_ENDIAN); }))) { 2471 mixin(enumMixinStr_PDP_ENDIAN); 2472 } 2473 } 2474 2475 2476 2477 2478 static if(!is(typeof(BIG_ENDIAN))) { 2479 private enum enumMixinStr_BIG_ENDIAN = `enum BIG_ENDIAN = __BIG_ENDIAN;`; 2480 static if(is(typeof({ mixin(enumMixinStr_BIG_ENDIAN); }))) { 2481 mixin(enumMixinStr_BIG_ENDIAN); 2482 } 2483 } 2484 2485 2486 2487 2488 static if(!is(typeof(LITTLE_ENDIAN))) { 2489 private enum enumMixinStr_LITTLE_ENDIAN = `enum LITTLE_ENDIAN = __LITTLE_ENDIAN;`; 2490 static if(is(typeof({ mixin(enumMixinStr_LITTLE_ENDIAN); }))) { 2491 mixin(enumMixinStr_LITTLE_ENDIAN); 2492 } 2493 } 2494 2495 2496 2497 2498 static if(!is(typeof(__FLOAT_WORD_ORDER))) { 2499 private enum enumMixinStr___FLOAT_WORD_ORDER = `enum __FLOAT_WORD_ORDER = __LITTLE_ENDIAN;`; 2500 static if(is(typeof({ mixin(enumMixinStr___FLOAT_WORD_ORDER); }))) { 2501 mixin(enumMixinStr___FLOAT_WORD_ORDER); 2502 } 2503 } 2504 2505 2506 2507 2508 static if(!is(typeof(__PDP_ENDIAN))) { 2509 private enum enumMixinStr___PDP_ENDIAN = `enum __PDP_ENDIAN = 3412;`; 2510 static if(is(typeof({ mixin(enumMixinStr___PDP_ENDIAN); }))) { 2511 mixin(enumMixinStr___PDP_ENDIAN); 2512 } 2513 } 2514 2515 2516 2517 2518 static if(!is(typeof(__BIG_ENDIAN))) { 2519 private enum enumMixinStr___BIG_ENDIAN = `enum __BIG_ENDIAN = 4321;`; 2520 static if(is(typeof({ mixin(enumMixinStr___BIG_ENDIAN); }))) { 2521 mixin(enumMixinStr___BIG_ENDIAN); 2522 } 2523 } 2524 2525 2526 2527 2528 static if(!is(typeof(__LITTLE_ENDIAN))) { 2529 private enum enumMixinStr___LITTLE_ENDIAN = `enum __LITTLE_ENDIAN = 1234;`; 2530 static if(is(typeof({ mixin(enumMixinStr___LITTLE_ENDIAN); }))) { 2531 mixin(enumMixinStr___LITTLE_ENDIAN); 2532 } 2533 } 2534 2535 2536 2537 2538 static if(!is(typeof(_ENDIAN_H))) { 2539 private enum enumMixinStr__ENDIAN_H = `enum _ENDIAN_H = 1;`; 2540 static if(is(typeof({ mixin(enumMixinStr__ENDIAN_H); }))) { 2541 mixin(enumMixinStr__ENDIAN_H); 2542 } 2543 } 2544 2545 2546 2547 2548 static if(!is(typeof(__GLIBC_USE_LIB_EXT2))) { 2549 private enum enumMixinStr___GLIBC_USE_LIB_EXT2 = `enum __GLIBC_USE_LIB_EXT2 = 0;`; 2550 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_LIB_EXT2); }))) { 2551 mixin(enumMixinStr___GLIBC_USE_LIB_EXT2); 2552 } 2553 } 2554 2555 2556 2557 2558 static if(!is(typeof(__GLIBC_USE_IEC_60559_BFP_EXT))) { 2559 private enum enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT = `enum __GLIBC_USE_IEC_60559_BFP_EXT = 0;`; 2560 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT); }))) { 2561 mixin(enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT); 2562 } 2563 } 2564 2565 2566 2567 2568 static if(!is(typeof(__GLIBC_USE_IEC_60559_FUNCS_EXT))) { 2569 private enum enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT = `enum __GLIBC_USE_IEC_60559_FUNCS_EXT = 0;`; 2570 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT); }))) { 2571 mixin(enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT); 2572 } 2573 } 2574 2575 2576 2577 2578 static if(!is(typeof(__GLIBC_USE_IEC_60559_TYPES_EXT))) { 2579 private enum enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT = `enum __GLIBC_USE_IEC_60559_TYPES_EXT = 0;`; 2580 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT); }))) { 2581 mixin(enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT); 2582 } 2583 } 2584 2585 2586 2587 2588 static if(!is(typeof(_BITS_PTHREADTYPES_ARCH_H))) { 2589 private enum enumMixinStr__BITS_PTHREADTYPES_ARCH_H = `enum _BITS_PTHREADTYPES_ARCH_H = 1;`; 2590 static if(is(typeof({ mixin(enumMixinStr__BITS_PTHREADTYPES_ARCH_H); }))) { 2591 mixin(enumMixinStr__BITS_PTHREADTYPES_ARCH_H); 2592 } 2593 } 2594 2595 2596 2597 2598 static if(!is(typeof(NULL))) { 2599 private enum enumMixinStr_NULL = `enum NULL = ( cast( void * ) 0 );`; 2600 static if(is(typeof({ mixin(enumMixinStr_NULL); }))) { 2601 mixin(enumMixinStr_NULL); 2602 } 2603 } 2604 static if(!is(typeof(__SIZEOF_PTHREAD_MUTEX_T))) { 2605 private enum enumMixinStr___SIZEOF_PTHREAD_MUTEX_T = `enum __SIZEOF_PTHREAD_MUTEX_T = 40;`; 2606 static if(is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_MUTEX_T); }))) { 2607 mixin(enumMixinStr___SIZEOF_PTHREAD_MUTEX_T); 2608 } 2609 } 2610 2611 2612 2613 2614 static if(!is(typeof(__SIZEOF_PTHREAD_ATTR_T))) { 2615 private enum enumMixinStr___SIZEOF_PTHREAD_ATTR_T = `enum __SIZEOF_PTHREAD_ATTR_T = 56;`; 2616 static if(is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_ATTR_T); }))) { 2617 mixin(enumMixinStr___SIZEOF_PTHREAD_ATTR_T); 2618 } 2619 } 2620 2621 2622 2623 2624 static if(!is(typeof(__SIZEOF_PTHREAD_RWLOCK_T))) { 2625 private enum enumMixinStr___SIZEOF_PTHREAD_RWLOCK_T = `enum __SIZEOF_PTHREAD_RWLOCK_T = 56;`; 2626 static if(is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_RWLOCK_T); }))) { 2627 mixin(enumMixinStr___SIZEOF_PTHREAD_RWLOCK_T); 2628 } 2629 } 2630 2631 2632 2633 2634 static if(!is(typeof(__SIZEOF_PTHREAD_BARRIER_T))) { 2635 private enum enumMixinStr___SIZEOF_PTHREAD_BARRIER_T = `enum __SIZEOF_PTHREAD_BARRIER_T = 32;`; 2636 static if(is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_BARRIER_T); }))) { 2637 mixin(enumMixinStr___SIZEOF_PTHREAD_BARRIER_T); 2638 } 2639 } 2640 2641 2642 2643 2644 static if(!is(typeof(__SIZEOF_PTHREAD_MUTEXATTR_T))) { 2645 private enum enumMixinStr___SIZEOF_PTHREAD_MUTEXATTR_T = `enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;`; 2646 static if(is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_MUTEXATTR_T); }))) { 2647 mixin(enumMixinStr___SIZEOF_PTHREAD_MUTEXATTR_T); 2648 } 2649 } 2650 2651 2652 2653 2654 static if(!is(typeof(__SIZEOF_PTHREAD_COND_T))) { 2655 private enum enumMixinStr___SIZEOF_PTHREAD_COND_T = `enum __SIZEOF_PTHREAD_COND_T = 48;`; 2656 static if(is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_COND_T); }))) { 2657 mixin(enumMixinStr___SIZEOF_PTHREAD_COND_T); 2658 } 2659 } 2660 2661 2662 2663 2664 static if(!is(typeof(__SIZEOF_PTHREAD_CONDATTR_T))) { 2665 private enum enumMixinStr___SIZEOF_PTHREAD_CONDATTR_T = `enum __SIZEOF_PTHREAD_CONDATTR_T = 4;`; 2666 static if(is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_CONDATTR_T); }))) { 2667 mixin(enumMixinStr___SIZEOF_PTHREAD_CONDATTR_T); 2668 } 2669 } 2670 2671 2672 2673 2674 static if(!is(typeof(__SIZEOF_PTHREAD_RWLOCKATTR_T))) { 2675 private enum enumMixinStr___SIZEOF_PTHREAD_RWLOCKATTR_T = `enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;`; 2676 static if(is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_RWLOCKATTR_T); }))) { 2677 mixin(enumMixinStr___SIZEOF_PTHREAD_RWLOCKATTR_T); 2678 } 2679 } 2680 2681 2682 2683 2684 static if(!is(typeof(__SIZEOF_PTHREAD_BARRIERATTR_T))) { 2685 private enum enumMixinStr___SIZEOF_PTHREAD_BARRIERATTR_T = `enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;`; 2686 static if(is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_BARRIERATTR_T); }))) { 2687 mixin(enumMixinStr___SIZEOF_PTHREAD_BARRIERATTR_T); 2688 } 2689 } 2690 static if(!is(typeof(__PTHREAD_MUTEX_LOCK_ELISION))) { 2691 private enum enumMixinStr___PTHREAD_MUTEX_LOCK_ELISION = `enum __PTHREAD_MUTEX_LOCK_ELISION = 1;`; 2692 static if(is(typeof({ mixin(enumMixinStr___PTHREAD_MUTEX_LOCK_ELISION); }))) { 2693 mixin(enumMixinStr___PTHREAD_MUTEX_LOCK_ELISION); 2694 } 2695 } 2696 2697 2698 2699 2700 static if(!is(typeof(__bool_true_false_are_defined))) { 2701 private enum enumMixinStr___bool_true_false_are_defined = `enum __bool_true_false_are_defined = 1;`; 2702 static if(is(typeof({ mixin(enumMixinStr___bool_true_false_are_defined); }))) { 2703 mixin(enumMixinStr___bool_true_false_are_defined); 2704 } 2705 } 2706 2707 2708 2709 2710 static if(!is(typeof(__PTHREAD_MUTEX_NUSERS_AFTER_KIND))) { 2711 private enum enumMixinStr___PTHREAD_MUTEX_NUSERS_AFTER_KIND = `enum __PTHREAD_MUTEX_NUSERS_AFTER_KIND = 0;`; 2712 static if(is(typeof({ mixin(enumMixinStr___PTHREAD_MUTEX_NUSERS_AFTER_KIND); }))) { 2713 mixin(enumMixinStr___PTHREAD_MUTEX_NUSERS_AFTER_KIND); 2714 } 2715 } 2716 2717 2718 2719 2720 static if(!is(typeof(__PTHREAD_MUTEX_USE_UNION))) { 2721 private enum enumMixinStr___PTHREAD_MUTEX_USE_UNION = `enum __PTHREAD_MUTEX_USE_UNION = 0;`; 2722 static if(is(typeof({ mixin(enumMixinStr___PTHREAD_MUTEX_USE_UNION); }))) { 2723 mixin(enumMixinStr___PTHREAD_MUTEX_USE_UNION); 2724 } 2725 } 2726 static if(!is(typeof(false_))) { 2727 private enum enumMixinStr_false_ = `enum false_ = 0;`; 2728 static if(is(typeof({ mixin(enumMixinStr_false_); }))) { 2729 mixin(enumMixinStr_false_); 2730 } 2731 } 2732 2733 2734 2735 2736 static if(!is(typeof(true_))) { 2737 private enum enumMixinStr_true_ = `enum true_ = 1;`; 2738 static if(is(typeof({ mixin(enumMixinStr_true_); }))) { 2739 mixin(enumMixinStr_true_); 2740 } 2741 } 2742 2743 2744 2745 2746 static if(!is(typeof(__PTHREAD_RWLOCK_ELISION_EXTRA))) { 2747 private enum enumMixinStr___PTHREAD_RWLOCK_ELISION_EXTRA = `enum __PTHREAD_RWLOCK_ELISION_EXTRA = 0 , { 0 , 0 , 0 , 0 , 0 , 0 , 0 };`; 2748 static if(is(typeof({ mixin(enumMixinStr___PTHREAD_RWLOCK_ELISION_EXTRA); }))) { 2749 mixin(enumMixinStr___PTHREAD_RWLOCK_ELISION_EXTRA); 2750 } 2751 } 2752 2753 2754 2755 2756 static if(!is(typeof(__PTHREAD_RWLOCK_INT_FLAGS_SHARED))) { 2757 private enum enumMixinStr___PTHREAD_RWLOCK_INT_FLAGS_SHARED = `enum __PTHREAD_RWLOCK_INT_FLAGS_SHARED = 1;`; 2758 static if(is(typeof({ mixin(enumMixinStr___PTHREAD_RWLOCK_INT_FLAGS_SHARED); }))) { 2759 mixin(enumMixinStr___PTHREAD_RWLOCK_INT_FLAGS_SHARED); 2760 } 2761 } 2762 2763 2764 2765 2766 static if(!is(typeof(bool_))) { 2767 private enum enumMixinStr_bool_ = `enum bool_ = _Bool;`; 2768 static if(is(typeof({ mixin(enumMixinStr_bool_); }))) { 2769 mixin(enumMixinStr_bool_); 2770 } 2771 } 2772 2773 2774 2775 2776 static if(!is(typeof(_BITS_PTHREADTYPES_COMMON_H))) { 2777 private enum enumMixinStr__BITS_PTHREADTYPES_COMMON_H = `enum _BITS_PTHREADTYPES_COMMON_H = 1;`; 2778 static if(is(typeof({ mixin(enumMixinStr__BITS_PTHREADTYPES_COMMON_H); }))) { 2779 mixin(enumMixinStr__BITS_PTHREADTYPES_COMMON_H); 2780 } 2781 } 2782 2783 2784 2785 2786 2787 2788 static if(!is(typeof(__GNUC_VA_LIST))) { 2789 private enum enumMixinStr___GNUC_VA_LIST = `enum __GNUC_VA_LIST = 1;`; 2790 static if(is(typeof({ mixin(enumMixinStr___GNUC_VA_LIST); }))) { 2791 mixin(enumMixinStr___GNUC_VA_LIST); 2792 } 2793 } 2794 static if(!is(typeof(_ALLOCA_H))) { 2795 private enum enumMixinStr__ALLOCA_H = `enum _ALLOCA_H = 1;`; 2796 static if(is(typeof({ mixin(enumMixinStr__ALLOCA_H); }))) { 2797 mixin(enumMixinStr__ALLOCA_H); 2798 } 2799 } 2800 2801 2802 2803 2804 static if(!is(typeof(WGPUTextureUsage_OUTPUT_ATTACHMENT))) { 2805 private enum enumMixinStr_WGPUTextureUsage_OUTPUT_ATTACHMENT = `enum WGPUTextureUsage_OUTPUT_ATTACHMENT = cast( uint32_t ) 16;`; 2806 static if(is(typeof({ mixin(enumMixinStr_WGPUTextureUsage_OUTPUT_ATTACHMENT); }))) { 2807 mixin(enumMixinStr_WGPUTextureUsage_OUTPUT_ATTACHMENT); 2808 } 2809 } 2810 2811 2812 2813 2814 static if(!is(typeof(WGPUTextureUsage_STORAGE))) { 2815 private enum enumMixinStr_WGPUTextureUsage_STORAGE = `enum WGPUTextureUsage_STORAGE = cast( uint32_t ) 8;`; 2816 static if(is(typeof({ mixin(enumMixinStr_WGPUTextureUsage_STORAGE); }))) { 2817 mixin(enumMixinStr_WGPUTextureUsage_STORAGE); 2818 } 2819 } 2820 2821 2822 2823 2824 static if(!is(typeof(__have_pthread_attr_t))) { 2825 private enum enumMixinStr___have_pthread_attr_t = `enum __have_pthread_attr_t = 1;`; 2826 static if(is(typeof({ mixin(enumMixinStr___have_pthread_attr_t); }))) { 2827 mixin(enumMixinStr___have_pthread_attr_t); 2828 } 2829 } 2830 2831 2832 2833 2834 static if(!is(typeof(WGPUTextureUsage_SAMPLED))) { 2835 private enum enumMixinStr_WGPUTextureUsage_SAMPLED = `enum WGPUTextureUsage_SAMPLED = cast( uint32_t ) 4;`; 2836 static if(is(typeof({ mixin(enumMixinStr_WGPUTextureUsage_SAMPLED); }))) { 2837 mixin(enumMixinStr_WGPUTextureUsage_SAMPLED); 2838 } 2839 } 2840 2841 2842 2843 2844 static if(!is(typeof(WGPUTextureUsage_COPY_DST))) { 2845 private enum enumMixinStr_WGPUTextureUsage_COPY_DST = `enum WGPUTextureUsage_COPY_DST = cast( uint32_t ) 2;`; 2846 static if(is(typeof({ mixin(enumMixinStr_WGPUTextureUsage_COPY_DST); }))) { 2847 mixin(enumMixinStr_WGPUTextureUsage_COPY_DST); 2848 } 2849 } 2850 2851 2852 2853 2854 static if(!is(typeof(WGPUTextureUsage_COPY_SRC))) { 2855 private enum enumMixinStr_WGPUTextureUsage_COPY_SRC = `enum WGPUTextureUsage_COPY_SRC = cast( uint32_t ) 1;`; 2856 static if(is(typeof({ mixin(enumMixinStr_WGPUTextureUsage_COPY_SRC); }))) { 2857 mixin(enumMixinStr_WGPUTextureUsage_COPY_SRC); 2858 } 2859 } 2860 2861 2862 2863 2864 static if(!is(typeof(WGPUColorWrite_ALL))) { 2865 private enum enumMixinStr_WGPUColorWrite_ALL = `enum WGPUColorWrite_ALL = cast( uint32_t ) 15;`; 2866 static if(is(typeof({ mixin(enumMixinStr_WGPUColorWrite_ALL); }))) { 2867 mixin(enumMixinStr_WGPUColorWrite_ALL); 2868 } 2869 } 2870 2871 2872 2873 2874 static if(!is(typeof(WGPUColorWrite_COLOR))) { 2875 private enum enumMixinStr_WGPUColorWrite_COLOR = `enum WGPUColorWrite_COLOR = cast( uint32_t ) 7;`; 2876 static if(is(typeof({ mixin(enumMixinStr_WGPUColorWrite_COLOR); }))) { 2877 mixin(enumMixinStr_WGPUColorWrite_COLOR); 2878 } 2879 } 2880 2881 2882 2883 2884 static if(!is(typeof(WGPUColorWrite_ALPHA))) { 2885 private enum enumMixinStr_WGPUColorWrite_ALPHA = `enum WGPUColorWrite_ALPHA = cast( uint32_t ) 8;`; 2886 static if(is(typeof({ mixin(enumMixinStr_WGPUColorWrite_ALPHA); }))) { 2887 mixin(enumMixinStr_WGPUColorWrite_ALPHA); 2888 } 2889 } 2890 2891 2892 2893 2894 static if(!is(typeof(WGPUColorWrite_BLUE))) { 2895 private enum enumMixinStr_WGPUColorWrite_BLUE = `enum WGPUColorWrite_BLUE = cast( uint32_t ) 4;`; 2896 static if(is(typeof({ mixin(enumMixinStr_WGPUColorWrite_BLUE); }))) { 2897 mixin(enumMixinStr_WGPUColorWrite_BLUE); 2898 } 2899 } 2900 2901 2902 2903 2904 static if(!is(typeof(WGPUColorWrite_GREEN))) { 2905 private enum enumMixinStr_WGPUColorWrite_GREEN = `enum WGPUColorWrite_GREEN = cast( uint32_t ) 2;`; 2906 static if(is(typeof({ mixin(enumMixinStr_WGPUColorWrite_GREEN); }))) { 2907 mixin(enumMixinStr_WGPUColorWrite_GREEN); 2908 } 2909 } 2910 2911 2912 2913 2914 static if(!is(typeof(WGPUColorWrite_RED))) { 2915 private enum enumMixinStr_WGPUColorWrite_RED = `enum WGPUColorWrite_RED = cast( uint32_t ) 1;`; 2916 static if(is(typeof({ mixin(enumMixinStr_WGPUColorWrite_RED); }))) { 2917 mixin(enumMixinStr_WGPUColorWrite_RED); 2918 } 2919 } 2920 2921 2922 2923 2924 static if(!is(typeof(WGPUBufferUsage_INDIRECT))) { 2925 private enum enumMixinStr_WGPUBufferUsage_INDIRECT = `enum WGPUBufferUsage_INDIRECT = cast( uint32_t ) 256;`; 2926 static if(is(typeof({ mixin(enumMixinStr_WGPUBufferUsage_INDIRECT); }))) { 2927 mixin(enumMixinStr_WGPUBufferUsage_INDIRECT); 2928 } 2929 } 2930 2931 2932 2933 2934 static if(!is(typeof(WGPUBufferUsage_STORAGE))) { 2935 private enum enumMixinStr_WGPUBufferUsage_STORAGE = `enum WGPUBufferUsage_STORAGE = cast( uint32_t ) 128;`; 2936 static if(is(typeof({ mixin(enumMixinStr_WGPUBufferUsage_STORAGE); }))) { 2937 mixin(enumMixinStr_WGPUBufferUsage_STORAGE); 2938 } 2939 } 2940 2941 2942 2943 2944 static if(!is(typeof(WGPUBufferUsage_UNIFORM))) { 2945 private enum enumMixinStr_WGPUBufferUsage_UNIFORM = `enum WGPUBufferUsage_UNIFORM = cast( uint32_t ) 64;`; 2946 static if(is(typeof({ mixin(enumMixinStr_WGPUBufferUsage_UNIFORM); }))) { 2947 mixin(enumMixinStr_WGPUBufferUsage_UNIFORM); 2948 } 2949 } 2950 2951 2952 2953 2954 static if(!is(typeof(WGPUBufferUsage_VERTEX))) { 2955 private enum enumMixinStr_WGPUBufferUsage_VERTEX = `enum WGPUBufferUsage_VERTEX = cast( uint32_t ) 32;`; 2956 static if(is(typeof({ mixin(enumMixinStr_WGPUBufferUsage_VERTEX); }))) { 2957 mixin(enumMixinStr_WGPUBufferUsage_VERTEX); 2958 } 2959 } 2960 2961 2962 2963 2964 static if(!is(typeof(WGPUBufferUsage_INDEX))) { 2965 private enum enumMixinStr_WGPUBufferUsage_INDEX = `enum WGPUBufferUsage_INDEX = cast( uint32_t ) 16;`; 2966 static if(is(typeof({ mixin(enumMixinStr_WGPUBufferUsage_INDEX); }))) { 2967 mixin(enumMixinStr_WGPUBufferUsage_INDEX); 2968 } 2969 } 2970 2971 2972 2973 2974 static if(!is(typeof(WGPUBufferUsage_COPY_DST))) { 2975 private enum enumMixinStr_WGPUBufferUsage_COPY_DST = `enum WGPUBufferUsage_COPY_DST = cast( uint32_t ) 8;`; 2976 static if(is(typeof({ mixin(enumMixinStr_WGPUBufferUsage_COPY_DST); }))) { 2977 mixin(enumMixinStr_WGPUBufferUsage_COPY_DST); 2978 } 2979 } 2980 2981 2982 2983 2984 static if(!is(typeof(WGPUBufferUsage_COPY_SRC))) { 2985 private enum enumMixinStr_WGPUBufferUsage_COPY_SRC = `enum WGPUBufferUsage_COPY_SRC = cast( uint32_t ) 4;`; 2986 static if(is(typeof({ mixin(enumMixinStr_WGPUBufferUsage_COPY_SRC); }))) { 2987 mixin(enumMixinStr_WGPUBufferUsage_COPY_SRC); 2988 } 2989 } 2990 2991 2992 2993 2994 static if(!is(typeof(WGPUBufferUsage_MAP_WRITE))) { 2995 private enum enumMixinStr_WGPUBufferUsage_MAP_WRITE = `enum WGPUBufferUsage_MAP_WRITE = cast( uint32_t ) 2;`; 2996 static if(is(typeof({ mixin(enumMixinStr_WGPUBufferUsage_MAP_WRITE); }))) { 2997 mixin(enumMixinStr_WGPUBufferUsage_MAP_WRITE); 2998 } 2999 } 3000 3001 3002 3003 3004 static if(!is(typeof(WGPUBufferUsage_MAP_READ))) { 3005 private enum enumMixinStr_WGPUBufferUsage_MAP_READ = `enum WGPUBufferUsage_MAP_READ = cast( uint32_t ) 1;`; 3006 static if(is(typeof({ mixin(enumMixinStr_WGPUBufferUsage_MAP_READ); }))) { 3007 mixin(enumMixinStr_WGPUBufferUsage_MAP_READ); 3008 } 3009 } 3010 3011 3012 3013 3014 static if(!is(typeof(WGPUShaderStage_COMPUTE))) { 3015 private enum enumMixinStr_WGPUShaderStage_COMPUTE = `enum WGPUShaderStage_COMPUTE = cast( uint32_t ) 4;`; 3016 static if(is(typeof({ mixin(enumMixinStr_WGPUShaderStage_COMPUTE); }))) { 3017 mixin(enumMixinStr_WGPUShaderStage_COMPUTE); 3018 } 3019 } 3020 3021 3022 3023 3024 static if(!is(typeof(WGPUShaderStage_FRAGMENT))) { 3025 private enum enumMixinStr_WGPUShaderStage_FRAGMENT = `enum WGPUShaderStage_FRAGMENT = cast( uint32_t ) 2;`; 3026 static if(is(typeof({ mixin(enumMixinStr_WGPUShaderStage_FRAGMENT); }))) { 3027 mixin(enumMixinStr_WGPUShaderStage_FRAGMENT); 3028 } 3029 } 3030 3031 3032 3033 3034 static if(!is(typeof(WGPUShaderStage_VERTEX))) { 3035 private enum enumMixinStr_WGPUShaderStage_VERTEX = `enum WGPUShaderStage_VERTEX = cast( uint32_t ) 1;`; 3036 static if(is(typeof({ mixin(enumMixinStr_WGPUShaderStage_VERTEX); }))) { 3037 mixin(enumMixinStr_WGPUShaderStage_VERTEX); 3038 } 3039 } 3040 3041 3042 3043 3044 static if(!is(typeof(WGPUShaderStage_NONE))) { 3045 private enum enumMixinStr_WGPUShaderStage_NONE = `enum WGPUShaderStage_NONE = cast( uint32_t ) 0;`; 3046 static if(is(typeof({ mixin(enumMixinStr_WGPUShaderStage_NONE); }))) { 3047 mixin(enumMixinStr_WGPUShaderStage_NONE); 3048 } 3049 } 3050 3051 3052 3053 3054 static if(!is(typeof(WGPUOrigin3d_ZERO))) { 3055 private enum enumMixinStr_WGPUOrigin3d_ZERO = `enum WGPUOrigin3d_ZERO = cast( WGPUOrigin3d ) { . x = 0 , . y = 0 , . z = 0 };`; 3056 static if(is(typeof({ mixin(enumMixinStr_WGPUOrigin3d_ZERO); }))) { 3057 mixin(enumMixinStr_WGPUOrigin3d_ZERO); 3058 } 3059 } 3060 3061 3062 3063 3064 static if(!is(typeof(WGPUColor_BLUE))) { 3065 private enum enumMixinStr_WGPUColor_BLUE = `enum WGPUColor_BLUE = cast( WGPUColor ) { . r = 0.0 , . g = 0.0 , . b = 1.0 , . a = 1.0 };`; 3066 static if(is(typeof({ mixin(enumMixinStr_WGPUColor_BLUE); }))) { 3067 mixin(enumMixinStr_WGPUColor_BLUE); 3068 } 3069 } 3070 3071 3072 3073 3074 static if(!is(typeof(WGPUColor_GREEN))) { 3075 private enum enumMixinStr_WGPUColor_GREEN = `enum WGPUColor_GREEN = cast( WGPUColor ) { . r = 0.0 , . g = 1.0 , . b = 0.0 , . a = 1.0 };`; 3076 static if(is(typeof({ mixin(enumMixinStr_WGPUColor_GREEN); }))) { 3077 mixin(enumMixinStr_WGPUColor_GREEN); 3078 } 3079 } 3080 3081 3082 3083 3084 static if(!is(typeof(WGPUColor_RED))) { 3085 private enum enumMixinStr_WGPUColor_RED = `enum WGPUColor_RED = cast( WGPUColor ) { . r = 1.0 , . g = 0.0 , . b = 0.0 , . a = 1.0 };`; 3086 static if(is(typeof({ mixin(enumMixinStr_WGPUColor_RED); }))) { 3087 mixin(enumMixinStr_WGPUColor_RED); 3088 } 3089 } 3090 3091 3092 3093 3094 static if(!is(typeof(__FD_ZERO_STOS))) { 3095 private enum enumMixinStr___FD_ZERO_STOS = `enum __FD_ZERO_STOS = "stosq";`; 3096 static if(is(typeof({ mixin(enumMixinStr___FD_ZERO_STOS); }))) { 3097 mixin(enumMixinStr___FD_ZERO_STOS); 3098 } 3099 } 3100 static if(!is(typeof(_BITS_STDINT_INTN_H))) { 3101 private enum enumMixinStr__BITS_STDINT_INTN_H = `enum _BITS_STDINT_INTN_H = 1;`; 3102 static if(is(typeof({ mixin(enumMixinStr__BITS_STDINT_INTN_H); }))) { 3103 mixin(enumMixinStr__BITS_STDINT_INTN_H); 3104 } 3105 } 3106 3107 3108 3109 3110 static if(!is(typeof(WGPUColor_WHITE))) { 3111 private enum enumMixinStr_WGPUColor_WHITE = `enum WGPUColor_WHITE = cast( WGPUColor ) { . r = 1.0 , . g = 1.0 , . b = 1.0 , . a = 1.0 };`; 3112 static if(is(typeof({ mixin(enumMixinStr_WGPUColor_WHITE); }))) { 3113 mixin(enumMixinStr_WGPUColor_WHITE); 3114 } 3115 } 3116 3117 3118 3119 3120 static if(!is(typeof(WGPUColor_BLACK))) { 3121 private enum enumMixinStr_WGPUColor_BLACK = `enum WGPUColor_BLACK = cast( WGPUColor ) { . r = 0.0 , . g = 0.0 , . b = 0.0 , . a = 1.0 };`; 3122 static if(is(typeof({ mixin(enumMixinStr_WGPUColor_BLACK); }))) { 3123 mixin(enumMixinStr_WGPUColor_BLACK); 3124 } 3125 } 3126 3127 3128 3129 3130 static if(!is(typeof(WGPUColor_TRANSPARENT))) { 3131 private enum enumMixinStr_WGPUColor_TRANSPARENT = `enum WGPUColor_TRANSPARENT = cast( WGPUColor ) { . r = 0.0 , . g = 0.0 , . b = 0.0 , . a = 0.0 };`; 3132 static if(is(typeof({ mixin(enumMixinStr_WGPUColor_TRANSPARENT); }))) { 3133 mixin(enumMixinStr_WGPUColor_TRANSPARENT); 3134 } 3135 } 3136 3137 3138 3139 3140 static if(!is(typeof(WGPUFeatures_ALL_NATIVE))) { 3141 private enum enumMixinStr_WGPUFeatures_ALL_NATIVE = `enum WGPUFeatures_ALL_NATIVE = cast( uint64_t ) 18446744073709486080ULL;`; 3142 static if(is(typeof({ mixin(enumMixinStr_WGPUFeatures_ALL_NATIVE); }))) { 3143 mixin(enumMixinStr_WGPUFeatures_ALL_NATIVE); 3144 } 3145 } 3146 3147 3148 3149 3150 static if(!is(typeof(WGPUFeatures_ALL_UNSAFE))) { 3151 private enum enumMixinStr_WGPUFeatures_ALL_UNSAFE = `enum WGPUFeatures_ALL_UNSAFE = cast( uint64_t ) 18446462598732840960ULL;`; 3152 static if(is(typeof({ mixin(enumMixinStr_WGPUFeatures_ALL_UNSAFE); }))) { 3153 mixin(enumMixinStr_WGPUFeatures_ALL_UNSAFE); 3154 } 3155 } 3156 3157 3158 3159 3160 static if(!is(typeof(_BITS_STDINT_UINTN_H))) { 3161 private enum enumMixinStr__BITS_STDINT_UINTN_H = `enum _BITS_STDINT_UINTN_H = 1;`; 3162 static if(is(typeof({ mixin(enumMixinStr__BITS_STDINT_UINTN_H); }))) { 3163 mixin(enumMixinStr__BITS_STDINT_UINTN_H); 3164 } 3165 } 3166 3167 3168 3169 3170 static if(!is(typeof(WGPUFeatures_ALL_WEBGPU))) { 3171 private enum enumMixinStr_WGPUFeatures_ALL_WEBGPU = `enum WGPUFeatures_ALL_WEBGPU = cast( uint64_t ) 65535;`; 3172 static if(is(typeof({ mixin(enumMixinStr_WGPUFeatures_ALL_WEBGPU); }))) { 3173 mixin(enumMixinStr_WGPUFeatures_ALL_WEBGPU); 3174 } 3175 } 3176 3177 3178 3179 3180 static if(!is(typeof(WGPUFeatures_MULTI_DRAW_INDIRECT_COUNT))) { 3181 private enum enumMixinStr_WGPUFeatures_MULTI_DRAW_INDIRECT_COUNT = `enum WGPUFeatures_MULTI_DRAW_INDIRECT_COUNT = cast( uint64_t ) 4194304;`; 3182 static if(is(typeof({ mixin(enumMixinStr_WGPUFeatures_MULTI_DRAW_INDIRECT_COUNT); }))) { 3183 mixin(enumMixinStr_WGPUFeatures_MULTI_DRAW_INDIRECT_COUNT); 3184 } 3185 } 3186 3187 3188 3189 3190 static if(!is(typeof(WGPUFeatures_MULTI_DRAW_INDIRECT))) { 3191 private enum enumMixinStr_WGPUFeatures_MULTI_DRAW_INDIRECT = `enum WGPUFeatures_MULTI_DRAW_INDIRECT = cast( uint64_t ) 2097152;`; 3192 static if(is(typeof({ mixin(enumMixinStr_WGPUFeatures_MULTI_DRAW_INDIRECT); }))) { 3193 mixin(enumMixinStr_WGPUFeatures_MULTI_DRAW_INDIRECT); 3194 } 3195 } 3196 3197 3198 3199 3200 static if(!is(typeof(WGPUFeatures_UNSIZED_BINDING_ARRAY))) { 3201 private enum enumMixinStr_WGPUFeatures_UNSIZED_BINDING_ARRAY = `enum WGPUFeatures_UNSIZED_BINDING_ARRAY = cast( uint64_t ) 1048576;`; 3202 static if(is(typeof({ mixin(enumMixinStr_WGPUFeatures_UNSIZED_BINDING_ARRAY); }))) { 3203 mixin(enumMixinStr_WGPUFeatures_UNSIZED_BINDING_ARRAY); 3204 } 3205 } 3206 3207 3208 3209 3210 static if(!is(typeof(WGPUFeatures_SAMPLED_TEXTURE_ARRAY_NON_UNIFORM_INDEXING))) { 3211 private enum enumMixinStr_WGPUFeatures_SAMPLED_TEXTURE_ARRAY_NON_UNIFORM_INDEXING = `enum WGPUFeatures_SAMPLED_TEXTURE_ARRAY_NON_UNIFORM_INDEXING = cast( uint64_t ) 524288;`; 3212 static if(is(typeof({ mixin(enumMixinStr_WGPUFeatures_SAMPLED_TEXTURE_ARRAY_NON_UNIFORM_INDEXING); }))) { 3213 mixin(enumMixinStr_WGPUFeatures_SAMPLED_TEXTURE_ARRAY_NON_UNIFORM_INDEXING); 3214 } 3215 } 3216 3217 3218 3219 3220 static if(!is(typeof(WGPUFeatures_SAMPLED_TEXTURE_ARRAY_DYNAMIC_INDEXING))) { 3221 private enum enumMixinStr_WGPUFeatures_SAMPLED_TEXTURE_ARRAY_DYNAMIC_INDEXING = `enum WGPUFeatures_SAMPLED_TEXTURE_ARRAY_DYNAMIC_INDEXING = cast( uint64_t ) 262144;`; 3222 static if(is(typeof({ mixin(enumMixinStr_WGPUFeatures_SAMPLED_TEXTURE_ARRAY_DYNAMIC_INDEXING); }))) { 3223 mixin(enumMixinStr_WGPUFeatures_SAMPLED_TEXTURE_ARRAY_DYNAMIC_INDEXING); 3224 } 3225 } 3226 3227 3228 3229 3230 static if(!is(typeof(_BITS_SYSMACROS_H))) { 3231 private enum enumMixinStr__BITS_SYSMACROS_H = `enum _BITS_SYSMACROS_H = 1;`; 3232 static if(is(typeof({ mixin(enumMixinStr__BITS_SYSMACROS_H); }))) { 3233 mixin(enumMixinStr__BITS_SYSMACROS_H); 3234 } 3235 } 3236 3237 3238 3239 3240 static if(!is(typeof(WGPUFeatures_SAMPLED_TEXTURE_BINDING_ARRAY))) { 3241 private enum enumMixinStr_WGPUFeatures_SAMPLED_TEXTURE_BINDING_ARRAY = `enum WGPUFeatures_SAMPLED_TEXTURE_BINDING_ARRAY = cast( uint64_t ) 131072;`; 3242 static if(is(typeof({ mixin(enumMixinStr_WGPUFeatures_SAMPLED_TEXTURE_BINDING_ARRAY); }))) { 3243 mixin(enumMixinStr_WGPUFeatures_SAMPLED_TEXTURE_BINDING_ARRAY); 3244 } 3245 } 3246 3247 3248 3249 3250 static if(!is(typeof(__SYSMACROS_DECLARE_MAJOR))) { 3251 private enum enumMixinStr___SYSMACROS_DECLARE_MAJOR = `enum __SYSMACROS_DECLARE_MAJOR = ( DECL_TEMPL ) DECL_TEMPL ( unsigned int , major , ( __dev_t __dev ) );`; 3252 static if(is(typeof({ mixin(enumMixinStr___SYSMACROS_DECLARE_MAJOR); }))) { 3253 mixin(enumMixinStr___SYSMACROS_DECLARE_MAJOR); 3254 } 3255 } 3256 3257 3258 3259 3260 static if(!is(typeof(__SYSMACROS_DEFINE_MAJOR))) { 3261 private enum enumMixinStr___SYSMACROS_DEFINE_MAJOR = `enum __SYSMACROS_DEFINE_MAJOR = ( DECL_TEMPL ) ( DECL_TEMPL ) DECL_TEMPL ( unsigned int , major , ( __dev_t __dev ) ) ( DECL_TEMPL ) { unsigned int __major ; __major = ( ( __dev & cast( __dev_t ) 0x00000000000fff00u ) >> 8 ) ; __major |= ( ( __dev & cast( __dev_t ) 0xfffff00000000000u ) >> 32 ) ; return __major ; };`; 3262 static if(is(typeof({ mixin(enumMixinStr___SYSMACROS_DEFINE_MAJOR); }))) { 3263 mixin(enumMixinStr___SYSMACROS_DEFINE_MAJOR); 3264 } 3265 } 3266 3267 3268 3269 3270 static if(!is(typeof(__SYSMACROS_DECLARE_MINOR))) { 3271 private enum enumMixinStr___SYSMACROS_DECLARE_MINOR = `enum __SYSMACROS_DECLARE_MINOR = ( DECL_TEMPL ) DECL_TEMPL ( unsigned int , minor , ( __dev_t __dev ) );`; 3272 static if(is(typeof({ mixin(enumMixinStr___SYSMACROS_DECLARE_MINOR); }))) { 3273 mixin(enumMixinStr___SYSMACROS_DECLARE_MINOR); 3274 } 3275 } 3276 3277 3278 3279 3280 static if(!is(typeof(__SYSMACROS_DEFINE_MINOR))) { 3281 private enum enumMixinStr___SYSMACROS_DEFINE_MINOR = `enum __SYSMACROS_DEFINE_MINOR = ( DECL_TEMPL ) ( DECL_TEMPL ) DECL_TEMPL ( unsigned int , minor , ( __dev_t __dev ) ) ( DECL_TEMPL ) { unsigned int __minor ; __minor = ( ( __dev & cast( __dev_t ) 0x00000000000000ffu ) >> 0 ) ; __minor |= ( ( __dev & cast( __dev_t ) 0x00000ffffff00000u ) >> 12 ) ; return __minor ; };`; 3282 static if(is(typeof({ mixin(enumMixinStr___SYSMACROS_DEFINE_MINOR); }))) { 3283 mixin(enumMixinStr___SYSMACROS_DEFINE_MINOR); 3284 } 3285 } 3286 3287 3288 3289 3290 static if(!is(typeof(__SYSMACROS_DECLARE_MAKEDEV))) { 3291 private enum enumMixinStr___SYSMACROS_DECLARE_MAKEDEV = `enum __SYSMACROS_DECLARE_MAKEDEV = ( DECL_TEMPL ) DECL_TEMPL ( __dev_t , makedev , ( unsigned int __major , unsigned int __minor ) );`; 3292 static if(is(typeof({ mixin(enumMixinStr___SYSMACROS_DECLARE_MAKEDEV); }))) { 3293 mixin(enumMixinStr___SYSMACROS_DECLARE_MAKEDEV); 3294 } 3295 } 3296 3297 3298 3299 3300 static if(!is(typeof(__SYSMACROS_DEFINE_MAKEDEV))) { 3301 private enum enumMixinStr___SYSMACROS_DEFINE_MAKEDEV = `enum __SYSMACROS_DEFINE_MAKEDEV = ( DECL_TEMPL ) ( DECL_TEMPL ) DECL_TEMPL ( __dev_t , makedev , ( unsigned int __major , unsigned int __minor ) ) ( DECL_TEMPL ) { __dev_t __dev ; __dev = ( ( cast( __dev_t ) ( __major & 0x00000fffu ) ) << 8 ) ; __dev |= ( ( cast( __dev_t ) ( __major & 0xfffff000u ) ) << 32 ) ; __dev |= ( ( cast( __dev_t ) ( __minor & 0x000000ffu ) ) << 0 ) ; __dev |= ( ( cast( __dev_t ) ( __minor & 0xffffff00u ) ) << 12 ) ; return __dev ; };`; 3302 static if(is(typeof({ mixin(enumMixinStr___SYSMACROS_DEFINE_MAKEDEV); }))) { 3303 mixin(enumMixinStr___SYSMACROS_DEFINE_MAKEDEV); 3304 } 3305 } 3306 3307 3308 3309 3310 static if(!is(typeof(_THREAD_SHARED_TYPES_H))) { 3311 private enum enumMixinStr__THREAD_SHARED_TYPES_H = `enum _THREAD_SHARED_TYPES_H = 1;`; 3312 static if(is(typeof({ mixin(enumMixinStr__THREAD_SHARED_TYPES_H); }))) { 3313 mixin(enumMixinStr__THREAD_SHARED_TYPES_H); 3314 } 3315 } 3316 3317 3318 3319 3320 static if(!is(typeof(WGPUFeatures_MAPPABLE_PRIMARY_BUFFERS))) { 3321 private enum enumMixinStr_WGPUFeatures_MAPPABLE_PRIMARY_BUFFERS = `enum WGPUFeatures_MAPPABLE_PRIMARY_BUFFERS = cast( uint64_t ) 65536;`; 3322 static if(is(typeof({ mixin(enumMixinStr_WGPUFeatures_MAPPABLE_PRIMARY_BUFFERS); }))) { 3323 mixin(enumMixinStr_WGPUFeatures_MAPPABLE_PRIMARY_BUFFERS); 3324 } 3325 } 3326 3327 3328 3329 3330 static if(!is(typeof(WGPUMAX_VERTEX_BUFFERS))) { 3331 private enum enumMixinStr_WGPUMAX_VERTEX_BUFFERS = `enum WGPUMAX_VERTEX_BUFFERS = 16;`; 3332 static if(is(typeof({ mixin(enumMixinStr_WGPUMAX_VERTEX_BUFFERS); }))) { 3333 mixin(enumMixinStr_WGPUMAX_VERTEX_BUFFERS); 3334 } 3335 } 3336 3337 3338 3339 3340 static if(!is(typeof(WGPUMAX_MIP_LEVELS))) { 3341 private enum enumMixinStr_WGPUMAX_MIP_LEVELS = `enum WGPUMAX_MIP_LEVELS = 16;`; 3342 static if(is(typeof({ mixin(enumMixinStr_WGPUMAX_MIP_LEVELS); }))) { 3343 mixin(enumMixinStr_WGPUMAX_MIP_LEVELS); 3344 } 3345 } 3346 3347 3348 3349 3350 static if(!is(typeof(WGPUMAX_COLOR_TARGETS))) { 3351 private enum enumMixinStr_WGPUMAX_COLOR_TARGETS = `enum WGPUMAX_COLOR_TARGETS = 4;`; 3352 static if(is(typeof({ mixin(enumMixinStr_WGPUMAX_COLOR_TARGETS); }))) { 3353 mixin(enumMixinStr_WGPUMAX_COLOR_TARGETS); 3354 } 3355 } 3356 3357 3358 3359 3360 static if(!is(typeof(WGPUMAX_ANISOTROPY))) { 3361 private enum enumMixinStr_WGPUMAX_ANISOTROPY = `enum WGPUMAX_ANISOTROPY = 16;`; 3362 static if(is(typeof({ mixin(enumMixinStr_WGPUMAX_ANISOTROPY); }))) { 3363 mixin(enumMixinStr_WGPUMAX_ANISOTROPY); 3364 } 3365 } 3366 3367 3368 3369 3370 static if(!is(typeof(WGPUDESIRED_NUM_FRAMES))) { 3371 private enum enumMixinStr_WGPUDESIRED_NUM_FRAMES = `enum WGPUDESIRED_NUM_FRAMES = 3;`; 3372 static if(is(typeof({ mixin(enumMixinStr_WGPUDESIRED_NUM_FRAMES); }))) { 3373 mixin(enumMixinStr_WGPUDESIRED_NUM_FRAMES); 3374 } 3375 } 3376 3377 3378 3379 3380 static if(!is(typeof(__PTHREAD_SPINS_DATA))) { 3381 private enum enumMixinStr___PTHREAD_SPINS_DATA = `enum __PTHREAD_SPINS_DATA = short __spins ; short __elision;`; 3382 static if(is(typeof({ mixin(enumMixinStr___PTHREAD_SPINS_DATA); }))) { 3383 mixin(enumMixinStr___PTHREAD_SPINS_DATA); 3384 } 3385 } 3386 3387 3388 3389 3390 static if(!is(typeof(__PTHREAD_SPINS))) { 3391 private enum enumMixinStr___PTHREAD_SPINS = `enum __PTHREAD_SPINS = 0 , 0;`; 3392 static if(is(typeof({ mixin(enumMixinStr___PTHREAD_SPINS); }))) { 3393 mixin(enumMixinStr___PTHREAD_SPINS); 3394 } 3395 } 3396 3397 3398 3399 3400 static if(!is(typeof(WGPUCOPY_BYTES_PER_ROW_ALIGNMENT))) { 3401 private enum enumMixinStr_WGPUCOPY_BYTES_PER_ROW_ALIGNMENT = `enum WGPUCOPY_BYTES_PER_ROW_ALIGNMENT = 256;`; 3402 static if(is(typeof({ mixin(enumMixinStr_WGPUCOPY_BYTES_PER_ROW_ALIGNMENT); }))) { 3403 mixin(enumMixinStr_WGPUCOPY_BYTES_PER_ROW_ALIGNMENT); 3404 } 3405 } 3406 3407 3408 3409 3410 static if(!is(typeof(__PTHREAD_MUTEX_HAVE_PREV))) { 3411 private enum enumMixinStr___PTHREAD_MUTEX_HAVE_PREV = `enum __PTHREAD_MUTEX_HAVE_PREV = 1;`; 3412 static if(is(typeof({ mixin(enumMixinStr___PTHREAD_MUTEX_HAVE_PREV); }))) { 3413 mixin(enumMixinStr___PTHREAD_MUTEX_HAVE_PREV); 3414 } 3415 } 3416 3417 3418 3419 3420 static if(!is(typeof(_BITS_TYPES_H))) { 3421 private enum enumMixinStr__BITS_TYPES_H = `enum _BITS_TYPES_H = 1;`; 3422 static if(is(typeof({ mixin(enumMixinStr__BITS_TYPES_H); }))) { 3423 mixin(enumMixinStr__BITS_TYPES_H); 3424 } 3425 } 3426 3427 3428 3429 3430 static if(!is(typeof(__S16_TYPE))) { 3431 private enum enumMixinStr___S16_TYPE = `enum __S16_TYPE = short int;`; 3432 static if(is(typeof({ mixin(enumMixinStr___S16_TYPE); }))) { 3433 mixin(enumMixinStr___S16_TYPE); 3434 } 3435 } 3436 3437 3438 3439 3440 static if(!is(typeof(__U16_TYPE))) { 3441 private enum enumMixinStr___U16_TYPE = `enum __U16_TYPE = unsigned short int;`; 3442 static if(is(typeof({ mixin(enumMixinStr___U16_TYPE); }))) { 3443 mixin(enumMixinStr___U16_TYPE); 3444 } 3445 } 3446 3447 3448 3449 3450 static if(!is(typeof(__S32_TYPE))) { 3451 private enum enumMixinStr___S32_TYPE = `enum __S32_TYPE = int;`; 3452 static if(is(typeof({ mixin(enumMixinStr___S32_TYPE); }))) { 3453 mixin(enumMixinStr___S32_TYPE); 3454 } 3455 } 3456 3457 3458 3459 3460 static if(!is(typeof(__U32_TYPE))) { 3461 private enum enumMixinStr___U32_TYPE = `enum __U32_TYPE = unsigned int;`; 3462 static if(is(typeof({ mixin(enumMixinStr___U32_TYPE); }))) { 3463 mixin(enumMixinStr___U32_TYPE); 3464 } 3465 } 3466 3467 3468 3469 3470 static if(!is(typeof(__SLONGWORD_TYPE))) { 3471 private enum enumMixinStr___SLONGWORD_TYPE = `enum __SLONGWORD_TYPE = long int;`; 3472 static if(is(typeof({ mixin(enumMixinStr___SLONGWORD_TYPE); }))) { 3473 mixin(enumMixinStr___SLONGWORD_TYPE); 3474 } 3475 } 3476 3477 3478 3479 3480 static if(!is(typeof(__ULONGWORD_TYPE))) { 3481 private enum enumMixinStr___ULONGWORD_TYPE = `enum __ULONGWORD_TYPE = unsigned long int;`; 3482 static if(is(typeof({ mixin(enumMixinStr___ULONGWORD_TYPE); }))) { 3483 mixin(enumMixinStr___ULONGWORD_TYPE); 3484 } 3485 } 3486 3487 3488 3489 3490 static if(!is(typeof(__SQUAD_TYPE))) { 3491 private enum enumMixinStr___SQUAD_TYPE = `enum __SQUAD_TYPE = long int;`; 3492 static if(is(typeof({ mixin(enumMixinStr___SQUAD_TYPE); }))) { 3493 mixin(enumMixinStr___SQUAD_TYPE); 3494 } 3495 } 3496 3497 3498 3499 3500 static if(!is(typeof(__UQUAD_TYPE))) { 3501 private enum enumMixinStr___UQUAD_TYPE = `enum __UQUAD_TYPE = unsigned long int;`; 3502 static if(is(typeof({ mixin(enumMixinStr___UQUAD_TYPE); }))) { 3503 mixin(enumMixinStr___UQUAD_TYPE); 3504 } 3505 } 3506 3507 3508 3509 3510 static if(!is(typeof(__SWORD_TYPE))) { 3511 private enum enumMixinStr___SWORD_TYPE = `enum __SWORD_TYPE = long int;`; 3512 static if(is(typeof({ mixin(enumMixinStr___SWORD_TYPE); }))) { 3513 mixin(enumMixinStr___SWORD_TYPE); 3514 } 3515 } 3516 3517 3518 3519 3520 static if(!is(typeof(__UWORD_TYPE))) { 3521 private enum enumMixinStr___UWORD_TYPE = `enum __UWORD_TYPE = unsigned long int;`; 3522 static if(is(typeof({ mixin(enumMixinStr___UWORD_TYPE); }))) { 3523 mixin(enumMixinStr___UWORD_TYPE); 3524 } 3525 } 3526 3527 3528 3529 3530 static if(!is(typeof(__SLONG32_TYPE))) { 3531 private enum enumMixinStr___SLONG32_TYPE = `enum __SLONG32_TYPE = int;`; 3532 static if(is(typeof({ mixin(enumMixinStr___SLONG32_TYPE); }))) { 3533 mixin(enumMixinStr___SLONG32_TYPE); 3534 } 3535 } 3536 3537 3538 3539 3540 static if(!is(typeof(__ULONG32_TYPE))) { 3541 private enum enumMixinStr___ULONG32_TYPE = `enum __ULONG32_TYPE = unsigned int;`; 3542 static if(is(typeof({ mixin(enumMixinStr___ULONG32_TYPE); }))) { 3543 mixin(enumMixinStr___ULONG32_TYPE); 3544 } 3545 } 3546 3547 3548 3549 3550 static if(!is(typeof(__S64_TYPE))) { 3551 private enum enumMixinStr___S64_TYPE = `enum __S64_TYPE = long int;`; 3552 static if(is(typeof({ mixin(enumMixinStr___S64_TYPE); }))) { 3553 mixin(enumMixinStr___S64_TYPE); 3554 } 3555 } 3556 3557 3558 3559 3560 static if(!is(typeof(__U64_TYPE))) { 3561 private enum enumMixinStr___U64_TYPE = `enum __U64_TYPE = unsigned long int;`; 3562 static if(is(typeof({ mixin(enumMixinStr___U64_TYPE); }))) { 3563 mixin(enumMixinStr___U64_TYPE); 3564 } 3565 } 3566 3567 3568 3569 3570 static if(!is(typeof(__STD_TYPE))) { 3571 private enum enumMixinStr___STD_TYPE = `enum __STD_TYPE = typedef;`; 3572 static if(is(typeof({ mixin(enumMixinStr___STD_TYPE); }))) { 3573 mixin(enumMixinStr___STD_TYPE); 3574 } 3575 } 3576 3577 3578 3579 3580 3581 3582 static if(!is(typeof(_SIGSET_NWORDS))) { 3583 private enum enumMixinStr__SIGSET_NWORDS = `enum _SIGSET_NWORDS = ( 1024 / ( 8 * ( unsigned long int ) .sizeof ) );`; 3584 static if(is(typeof({ mixin(enumMixinStr__SIGSET_NWORDS); }))) { 3585 mixin(enumMixinStr__SIGSET_NWORDS); 3586 } 3587 } 3588 3589 3590 3591 3592 static if(!is(typeof(__clock_t_defined))) { 3593 private enum enumMixinStr___clock_t_defined = `enum __clock_t_defined = 1;`; 3594 static if(is(typeof({ mixin(enumMixinStr___clock_t_defined); }))) { 3595 mixin(enumMixinStr___clock_t_defined); 3596 } 3597 } 3598 3599 3600 3601 3602 static if(!is(typeof(__clockid_t_defined))) { 3603 private enum enumMixinStr___clockid_t_defined = `enum __clockid_t_defined = 1;`; 3604 static if(is(typeof({ mixin(enumMixinStr___clockid_t_defined); }))) { 3605 mixin(enumMixinStr___clockid_t_defined); 3606 } 3607 } 3608 3609 3610 3611 3612 static if(!is(typeof(__sigset_t_defined))) { 3613 private enum enumMixinStr___sigset_t_defined = `enum __sigset_t_defined = 1;`; 3614 static if(is(typeof({ mixin(enumMixinStr___sigset_t_defined); }))) { 3615 mixin(enumMixinStr___sigset_t_defined); 3616 } 3617 } 3618 3619 3620 3621 3622 static if(!is(typeof(__timespec_defined))) { 3623 private enum enumMixinStr___timespec_defined = `enum __timespec_defined = 1;`; 3624 static if(is(typeof({ mixin(enumMixinStr___timespec_defined); }))) { 3625 mixin(enumMixinStr___timespec_defined); 3626 } 3627 } 3628 3629 3630 3631 3632 static if(!is(typeof(__timeval_defined))) { 3633 private enum enumMixinStr___timeval_defined = `enum __timeval_defined = 1;`; 3634 static if(is(typeof({ mixin(enumMixinStr___timeval_defined); }))) { 3635 mixin(enumMixinStr___timeval_defined); 3636 } 3637 } 3638 3639 3640 3641 3642 static if(!is(typeof(__time_t_defined))) { 3643 private enum enumMixinStr___time_t_defined = `enum __time_t_defined = 1;`; 3644 static if(is(typeof({ mixin(enumMixinStr___time_t_defined); }))) { 3645 mixin(enumMixinStr___time_t_defined); 3646 } 3647 } 3648 3649 3650 3651 3652 static if(!is(typeof(__timer_t_defined))) { 3653 private enum enumMixinStr___timer_t_defined = `enum __timer_t_defined = 1;`; 3654 static if(is(typeof({ mixin(enumMixinStr___timer_t_defined); }))) { 3655 mixin(enumMixinStr___timer_t_defined); 3656 } 3657 } 3658 3659 3660 3661 3662 static if(!is(typeof(_BITS_TYPESIZES_H))) { 3663 private enum enumMixinStr__BITS_TYPESIZES_H = `enum _BITS_TYPESIZES_H = 1;`; 3664 static if(is(typeof({ mixin(enumMixinStr__BITS_TYPESIZES_H); }))) { 3665 mixin(enumMixinStr__BITS_TYPESIZES_H); 3666 } 3667 } 3668 3669 3670 3671 3672 static if(!is(typeof(__SYSCALL_SLONG_TYPE))) { 3673 private enum enumMixinStr___SYSCALL_SLONG_TYPE = `enum __SYSCALL_SLONG_TYPE = long int;`; 3674 static if(is(typeof({ mixin(enumMixinStr___SYSCALL_SLONG_TYPE); }))) { 3675 mixin(enumMixinStr___SYSCALL_SLONG_TYPE); 3676 } 3677 } 3678 3679 3680 3681 3682 static if(!is(typeof(__SYSCALL_ULONG_TYPE))) { 3683 private enum enumMixinStr___SYSCALL_ULONG_TYPE = `enum __SYSCALL_ULONG_TYPE = unsigned long int;`; 3684 static if(is(typeof({ mixin(enumMixinStr___SYSCALL_ULONG_TYPE); }))) { 3685 mixin(enumMixinStr___SYSCALL_ULONG_TYPE); 3686 } 3687 } 3688 3689 3690 3691 3692 static if(!is(typeof(__DEV_T_TYPE))) { 3693 private enum enumMixinStr___DEV_T_TYPE = `enum __DEV_T_TYPE = unsigned long int;`; 3694 static if(is(typeof({ mixin(enumMixinStr___DEV_T_TYPE); }))) { 3695 mixin(enumMixinStr___DEV_T_TYPE); 3696 } 3697 } 3698 3699 3700 3701 3702 static if(!is(typeof(__UID_T_TYPE))) { 3703 private enum enumMixinStr___UID_T_TYPE = `enum __UID_T_TYPE = unsigned int;`; 3704 static if(is(typeof({ mixin(enumMixinStr___UID_T_TYPE); }))) { 3705 mixin(enumMixinStr___UID_T_TYPE); 3706 } 3707 } 3708 3709 3710 3711 3712 static if(!is(typeof(__GID_T_TYPE))) { 3713 private enum enumMixinStr___GID_T_TYPE = `enum __GID_T_TYPE = unsigned int;`; 3714 static if(is(typeof({ mixin(enumMixinStr___GID_T_TYPE); }))) { 3715 mixin(enumMixinStr___GID_T_TYPE); 3716 } 3717 } 3718 3719 3720 3721 3722 static if(!is(typeof(__INO_T_TYPE))) { 3723 private enum enumMixinStr___INO_T_TYPE = `enum __INO_T_TYPE = unsigned long int;`; 3724 static if(is(typeof({ mixin(enumMixinStr___INO_T_TYPE); }))) { 3725 mixin(enumMixinStr___INO_T_TYPE); 3726 } 3727 } 3728 3729 3730 3731 3732 static if(!is(typeof(__INO64_T_TYPE))) { 3733 private enum enumMixinStr___INO64_T_TYPE = `enum __INO64_T_TYPE = unsigned long int;`; 3734 static if(is(typeof({ mixin(enumMixinStr___INO64_T_TYPE); }))) { 3735 mixin(enumMixinStr___INO64_T_TYPE); 3736 } 3737 } 3738 3739 3740 3741 3742 static if(!is(typeof(__MODE_T_TYPE))) { 3743 private enum enumMixinStr___MODE_T_TYPE = `enum __MODE_T_TYPE = unsigned int;`; 3744 static if(is(typeof({ mixin(enumMixinStr___MODE_T_TYPE); }))) { 3745 mixin(enumMixinStr___MODE_T_TYPE); 3746 } 3747 } 3748 3749 3750 3751 3752 static if(!is(typeof(__NLINK_T_TYPE))) { 3753 private enum enumMixinStr___NLINK_T_TYPE = `enum __NLINK_T_TYPE = unsigned long int;`; 3754 static if(is(typeof({ mixin(enumMixinStr___NLINK_T_TYPE); }))) { 3755 mixin(enumMixinStr___NLINK_T_TYPE); 3756 } 3757 } 3758 3759 3760 3761 3762 static if(!is(typeof(__FSWORD_T_TYPE))) { 3763 private enum enumMixinStr___FSWORD_T_TYPE = `enum __FSWORD_T_TYPE = long int;`; 3764 static if(is(typeof({ mixin(enumMixinStr___FSWORD_T_TYPE); }))) { 3765 mixin(enumMixinStr___FSWORD_T_TYPE); 3766 } 3767 } 3768 3769 3770 3771 3772 static if(!is(typeof(__OFF_T_TYPE))) { 3773 private enum enumMixinStr___OFF_T_TYPE = `enum __OFF_T_TYPE = long int;`; 3774 static if(is(typeof({ mixin(enumMixinStr___OFF_T_TYPE); }))) { 3775 mixin(enumMixinStr___OFF_T_TYPE); 3776 } 3777 } 3778 3779 3780 3781 3782 static if(!is(typeof(__OFF64_T_TYPE))) { 3783 private enum enumMixinStr___OFF64_T_TYPE = `enum __OFF64_T_TYPE = long int;`; 3784 static if(is(typeof({ mixin(enumMixinStr___OFF64_T_TYPE); }))) { 3785 mixin(enumMixinStr___OFF64_T_TYPE); 3786 } 3787 } 3788 3789 3790 3791 3792 static if(!is(typeof(__PID_T_TYPE))) { 3793 private enum enumMixinStr___PID_T_TYPE = `enum __PID_T_TYPE = int;`; 3794 static if(is(typeof({ mixin(enumMixinStr___PID_T_TYPE); }))) { 3795 mixin(enumMixinStr___PID_T_TYPE); 3796 } 3797 } 3798 3799 3800 3801 3802 static if(!is(typeof(__RLIM_T_TYPE))) { 3803 private enum enumMixinStr___RLIM_T_TYPE = `enum __RLIM_T_TYPE = unsigned long int;`; 3804 static if(is(typeof({ mixin(enumMixinStr___RLIM_T_TYPE); }))) { 3805 mixin(enumMixinStr___RLIM_T_TYPE); 3806 } 3807 } 3808 3809 3810 3811 3812 static if(!is(typeof(__RLIM64_T_TYPE))) { 3813 private enum enumMixinStr___RLIM64_T_TYPE = `enum __RLIM64_T_TYPE = unsigned long int;`; 3814 static if(is(typeof({ mixin(enumMixinStr___RLIM64_T_TYPE); }))) { 3815 mixin(enumMixinStr___RLIM64_T_TYPE); 3816 } 3817 } 3818 3819 3820 3821 3822 static if(!is(typeof(__BLKCNT_T_TYPE))) { 3823 private enum enumMixinStr___BLKCNT_T_TYPE = `enum __BLKCNT_T_TYPE = long int;`; 3824 static if(is(typeof({ mixin(enumMixinStr___BLKCNT_T_TYPE); }))) { 3825 mixin(enumMixinStr___BLKCNT_T_TYPE); 3826 } 3827 } 3828 3829 3830 3831 3832 static if(!is(typeof(__BLKCNT64_T_TYPE))) { 3833 private enum enumMixinStr___BLKCNT64_T_TYPE = `enum __BLKCNT64_T_TYPE = long int;`; 3834 static if(is(typeof({ mixin(enumMixinStr___BLKCNT64_T_TYPE); }))) { 3835 mixin(enumMixinStr___BLKCNT64_T_TYPE); 3836 } 3837 } 3838 3839 3840 3841 3842 static if(!is(typeof(__FSBLKCNT_T_TYPE))) { 3843 private enum enumMixinStr___FSBLKCNT_T_TYPE = `enum __FSBLKCNT_T_TYPE = unsigned long int;`; 3844 static if(is(typeof({ mixin(enumMixinStr___FSBLKCNT_T_TYPE); }))) { 3845 mixin(enumMixinStr___FSBLKCNT_T_TYPE); 3846 } 3847 } 3848 3849 3850 3851 3852 static if(!is(typeof(__FSBLKCNT64_T_TYPE))) { 3853 private enum enumMixinStr___FSBLKCNT64_T_TYPE = `enum __FSBLKCNT64_T_TYPE = unsigned long int;`; 3854 static if(is(typeof({ mixin(enumMixinStr___FSBLKCNT64_T_TYPE); }))) { 3855 mixin(enumMixinStr___FSBLKCNT64_T_TYPE); 3856 } 3857 } 3858 3859 3860 3861 3862 static if(!is(typeof(__FSFILCNT_T_TYPE))) { 3863 private enum enumMixinStr___FSFILCNT_T_TYPE = `enum __FSFILCNT_T_TYPE = unsigned long int;`; 3864 static if(is(typeof({ mixin(enumMixinStr___FSFILCNT_T_TYPE); }))) { 3865 mixin(enumMixinStr___FSFILCNT_T_TYPE); 3866 } 3867 } 3868 3869 3870 3871 3872 static if(!is(typeof(__FSFILCNT64_T_TYPE))) { 3873 private enum enumMixinStr___FSFILCNT64_T_TYPE = `enum __FSFILCNT64_T_TYPE = unsigned long int;`; 3874 static if(is(typeof({ mixin(enumMixinStr___FSFILCNT64_T_TYPE); }))) { 3875 mixin(enumMixinStr___FSFILCNT64_T_TYPE); 3876 } 3877 } 3878 3879 3880 3881 3882 static if(!is(typeof(__ID_T_TYPE))) { 3883 private enum enumMixinStr___ID_T_TYPE = `enum __ID_T_TYPE = unsigned int;`; 3884 static if(is(typeof({ mixin(enumMixinStr___ID_T_TYPE); }))) { 3885 mixin(enumMixinStr___ID_T_TYPE); 3886 } 3887 } 3888 3889 3890 3891 3892 static if(!is(typeof(__CLOCK_T_TYPE))) { 3893 private enum enumMixinStr___CLOCK_T_TYPE = `enum __CLOCK_T_TYPE = long int;`; 3894 static if(is(typeof({ mixin(enumMixinStr___CLOCK_T_TYPE); }))) { 3895 mixin(enumMixinStr___CLOCK_T_TYPE); 3896 } 3897 } 3898 3899 3900 3901 3902 static if(!is(typeof(__TIME_T_TYPE))) { 3903 private enum enumMixinStr___TIME_T_TYPE = `enum __TIME_T_TYPE = long int;`; 3904 static if(is(typeof({ mixin(enumMixinStr___TIME_T_TYPE); }))) { 3905 mixin(enumMixinStr___TIME_T_TYPE); 3906 } 3907 } 3908 3909 3910 3911 3912 static if(!is(typeof(__USECONDS_T_TYPE))) { 3913 private enum enumMixinStr___USECONDS_T_TYPE = `enum __USECONDS_T_TYPE = unsigned int;`; 3914 static if(is(typeof({ mixin(enumMixinStr___USECONDS_T_TYPE); }))) { 3915 mixin(enumMixinStr___USECONDS_T_TYPE); 3916 } 3917 } 3918 3919 3920 3921 3922 static if(!is(typeof(__SUSECONDS_T_TYPE))) { 3923 private enum enumMixinStr___SUSECONDS_T_TYPE = `enum __SUSECONDS_T_TYPE = long int;`; 3924 static if(is(typeof({ mixin(enumMixinStr___SUSECONDS_T_TYPE); }))) { 3925 mixin(enumMixinStr___SUSECONDS_T_TYPE); 3926 } 3927 } 3928 3929 3930 3931 3932 static if(!is(typeof(__DADDR_T_TYPE))) { 3933 private enum enumMixinStr___DADDR_T_TYPE = `enum __DADDR_T_TYPE = int;`; 3934 static if(is(typeof({ mixin(enumMixinStr___DADDR_T_TYPE); }))) { 3935 mixin(enumMixinStr___DADDR_T_TYPE); 3936 } 3937 } 3938 3939 3940 3941 3942 static if(!is(typeof(__KEY_T_TYPE))) { 3943 private enum enumMixinStr___KEY_T_TYPE = `enum __KEY_T_TYPE = int;`; 3944 static if(is(typeof({ mixin(enumMixinStr___KEY_T_TYPE); }))) { 3945 mixin(enumMixinStr___KEY_T_TYPE); 3946 } 3947 } 3948 3949 3950 3951 3952 static if(!is(typeof(__CLOCKID_T_TYPE))) { 3953 private enum enumMixinStr___CLOCKID_T_TYPE = `enum __CLOCKID_T_TYPE = int;`; 3954 static if(is(typeof({ mixin(enumMixinStr___CLOCKID_T_TYPE); }))) { 3955 mixin(enumMixinStr___CLOCKID_T_TYPE); 3956 } 3957 } 3958 3959 3960 3961 3962 static if(!is(typeof(__TIMER_T_TYPE))) { 3963 private enum enumMixinStr___TIMER_T_TYPE = `enum __TIMER_T_TYPE = void *;`; 3964 static if(is(typeof({ mixin(enumMixinStr___TIMER_T_TYPE); }))) { 3965 mixin(enumMixinStr___TIMER_T_TYPE); 3966 } 3967 } 3968 3969 3970 3971 3972 static if(!is(typeof(__BLKSIZE_T_TYPE))) { 3973 private enum enumMixinStr___BLKSIZE_T_TYPE = `enum __BLKSIZE_T_TYPE = long int;`; 3974 static if(is(typeof({ mixin(enumMixinStr___BLKSIZE_T_TYPE); }))) { 3975 mixin(enumMixinStr___BLKSIZE_T_TYPE); 3976 } 3977 } 3978 3979 3980 3981 3982 static if(!is(typeof(__FSID_T_TYPE))) { 3983 private enum enumMixinStr___FSID_T_TYPE = `enum __FSID_T_TYPE = { int __val [ 2 ] ; };`; 3984 static if(is(typeof({ mixin(enumMixinStr___FSID_T_TYPE); }))) { 3985 mixin(enumMixinStr___FSID_T_TYPE); 3986 } 3987 } 3988 3989 3990 3991 3992 static if(!is(typeof(__SSIZE_T_TYPE))) { 3993 private enum enumMixinStr___SSIZE_T_TYPE = `enum __SSIZE_T_TYPE = long int;`; 3994 static if(is(typeof({ mixin(enumMixinStr___SSIZE_T_TYPE); }))) { 3995 mixin(enumMixinStr___SSIZE_T_TYPE); 3996 } 3997 } 3998 3999 4000 4001 4002 static if(!is(typeof(__CPU_MASK_TYPE))) { 4003 private enum enumMixinStr___CPU_MASK_TYPE = `enum __CPU_MASK_TYPE = unsigned long int;`; 4004 static if(is(typeof({ mixin(enumMixinStr___CPU_MASK_TYPE); }))) { 4005 mixin(enumMixinStr___CPU_MASK_TYPE); 4006 } 4007 } 4008 4009 4010 4011 4012 static if(!is(typeof(__OFF_T_MATCHES_OFF64_T))) { 4013 private enum enumMixinStr___OFF_T_MATCHES_OFF64_T = `enum __OFF_T_MATCHES_OFF64_T = 1;`; 4014 static if(is(typeof({ mixin(enumMixinStr___OFF_T_MATCHES_OFF64_T); }))) { 4015 mixin(enumMixinStr___OFF_T_MATCHES_OFF64_T); 4016 } 4017 } 4018 4019 4020 4021 4022 static if(!is(typeof(__INO_T_MATCHES_INO64_T))) { 4023 private enum enumMixinStr___INO_T_MATCHES_INO64_T = `enum __INO_T_MATCHES_INO64_T = 1;`; 4024 static if(is(typeof({ mixin(enumMixinStr___INO_T_MATCHES_INO64_T); }))) { 4025 mixin(enumMixinStr___INO_T_MATCHES_INO64_T); 4026 } 4027 } 4028 4029 4030 4031 4032 static if(!is(typeof(__RLIM_T_MATCHES_RLIM64_T))) { 4033 private enum enumMixinStr___RLIM_T_MATCHES_RLIM64_T = `enum __RLIM_T_MATCHES_RLIM64_T = 1;`; 4034 static if(is(typeof({ mixin(enumMixinStr___RLIM_T_MATCHES_RLIM64_T); }))) { 4035 mixin(enumMixinStr___RLIM_T_MATCHES_RLIM64_T); 4036 } 4037 } 4038 4039 4040 4041 4042 static if(!is(typeof(__FD_SETSIZE))) { 4043 private enum enumMixinStr___FD_SETSIZE = `enum __FD_SETSIZE = 1024;`; 4044 static if(is(typeof({ mixin(enumMixinStr___FD_SETSIZE); }))) { 4045 mixin(enumMixinStr___FD_SETSIZE); 4046 } 4047 } 4048 4049 4050 4051 4052 static if(!is(typeof(_BITS_UINTN_IDENTITY_H))) { 4053 private enum enumMixinStr__BITS_UINTN_IDENTITY_H = `enum _BITS_UINTN_IDENTITY_H = 1;`; 4054 static if(is(typeof({ mixin(enumMixinStr__BITS_UINTN_IDENTITY_H); }))) { 4055 mixin(enumMixinStr__BITS_UINTN_IDENTITY_H); 4056 } 4057 } 4058 4059 4060 4061 4062 static if(!is(typeof(WNOHANG))) { 4063 private enum enumMixinStr_WNOHANG = `enum WNOHANG = 1;`; 4064 static if(is(typeof({ mixin(enumMixinStr_WNOHANG); }))) { 4065 mixin(enumMixinStr_WNOHANG); 4066 } 4067 } 4068 4069 4070 4071 4072 static if(!is(typeof(WUNTRACED))) { 4073 private enum enumMixinStr_WUNTRACED = `enum WUNTRACED = 2;`; 4074 static if(is(typeof({ mixin(enumMixinStr_WUNTRACED); }))) { 4075 mixin(enumMixinStr_WUNTRACED); 4076 } 4077 } 4078 4079 4080 4081 4082 static if(!is(typeof(WSTOPPED))) { 4083 private enum enumMixinStr_WSTOPPED = `enum WSTOPPED = 2;`; 4084 static if(is(typeof({ mixin(enumMixinStr_WSTOPPED); }))) { 4085 mixin(enumMixinStr_WSTOPPED); 4086 } 4087 } 4088 4089 4090 4091 4092 static if(!is(typeof(WEXITED))) { 4093 private enum enumMixinStr_WEXITED = `enum WEXITED = 4;`; 4094 static if(is(typeof({ mixin(enumMixinStr_WEXITED); }))) { 4095 mixin(enumMixinStr_WEXITED); 4096 } 4097 } 4098 4099 4100 4101 4102 static if(!is(typeof(WCONTINUED))) { 4103 private enum enumMixinStr_WCONTINUED = `enum WCONTINUED = 8;`; 4104 static if(is(typeof({ mixin(enumMixinStr_WCONTINUED); }))) { 4105 mixin(enumMixinStr_WCONTINUED); 4106 } 4107 } 4108 4109 4110 4111 4112 static if(!is(typeof(WNOWAIT))) { 4113 private enum enumMixinStr_WNOWAIT = `enum WNOWAIT = 0x01000000;`; 4114 static if(is(typeof({ mixin(enumMixinStr_WNOWAIT); }))) { 4115 mixin(enumMixinStr_WNOWAIT); 4116 } 4117 } 4118 4119 4120 4121 4122 static if(!is(typeof(__WNOTHREAD))) { 4123 private enum enumMixinStr___WNOTHREAD = `enum __WNOTHREAD = 0x20000000;`; 4124 static if(is(typeof({ mixin(enumMixinStr___WNOTHREAD); }))) { 4125 mixin(enumMixinStr___WNOTHREAD); 4126 } 4127 } 4128 4129 4130 4131 4132 static if(!is(typeof(__WALL))) { 4133 private enum enumMixinStr___WALL = `enum __WALL = 0x40000000;`; 4134 static if(is(typeof({ mixin(enumMixinStr___WALL); }))) { 4135 mixin(enumMixinStr___WALL); 4136 } 4137 } 4138 4139 4140 4141 4142 static if(!is(typeof(__WCLONE))) { 4143 private enum enumMixinStr___WCLONE = `enum __WCLONE = 0x80000000;`; 4144 static if(is(typeof({ mixin(enumMixinStr___WCLONE); }))) { 4145 mixin(enumMixinStr___WCLONE); 4146 } 4147 } 4148 4149 4150 4151 4152 static if(!is(typeof(__ENUM_IDTYPE_T))) { 4153 private enum enumMixinStr___ENUM_IDTYPE_T = `enum __ENUM_IDTYPE_T = 1;`; 4154 static if(is(typeof({ mixin(enumMixinStr___ENUM_IDTYPE_T); }))) { 4155 mixin(enumMixinStr___ENUM_IDTYPE_T); 4156 } 4157 } 4158 static if(!is(typeof(__W_CONTINUED))) { 4159 private enum enumMixinStr___W_CONTINUED = `enum __W_CONTINUED = 0xffff;`; 4160 static if(is(typeof({ mixin(enumMixinStr___W_CONTINUED); }))) { 4161 mixin(enumMixinStr___W_CONTINUED); 4162 } 4163 } 4164 4165 4166 4167 4168 static if(!is(typeof(__WCOREFLAG))) { 4169 private enum enumMixinStr___WCOREFLAG = `enum __WCOREFLAG = 0x80;`; 4170 static if(is(typeof({ mixin(enumMixinStr___WCOREFLAG); }))) { 4171 mixin(enumMixinStr___WCOREFLAG); 4172 } 4173 } 4174 4175 4176 4177 4178 static if(!is(typeof(_BITS_WCHAR_H))) { 4179 private enum enumMixinStr__BITS_WCHAR_H = `enum _BITS_WCHAR_H = 1;`; 4180 static if(is(typeof({ mixin(enumMixinStr__BITS_WCHAR_H); }))) { 4181 mixin(enumMixinStr__BITS_WCHAR_H); 4182 } 4183 } 4184 4185 4186 4187 4188 static if(!is(typeof(__WCHAR_MAX))) { 4189 private enum enumMixinStr___WCHAR_MAX = `enum __WCHAR_MAX = 0x7fffffff;`; 4190 static if(is(typeof({ mixin(enumMixinStr___WCHAR_MAX); }))) { 4191 mixin(enumMixinStr___WCHAR_MAX); 4192 } 4193 } 4194 4195 4196 4197 4198 static if(!is(typeof(__WCHAR_MIN))) { 4199 private enum enumMixinStr___WCHAR_MIN = `enum __WCHAR_MIN = ( - 0x7fffffff - 1 );`; 4200 static if(is(typeof({ mixin(enumMixinStr___WCHAR_MIN); }))) { 4201 mixin(enumMixinStr___WCHAR_MIN); 4202 } 4203 } 4204 4205 4206 4207 4208 static if(!is(typeof(__WORDSIZE))) { 4209 private enum enumMixinStr___WORDSIZE = `enum __WORDSIZE = 64;`; 4210 static if(is(typeof({ mixin(enumMixinStr___WORDSIZE); }))) { 4211 mixin(enumMixinStr___WORDSIZE); 4212 } 4213 } 4214 4215 4216 4217 4218 static if(!is(typeof(__WORDSIZE_TIME64_COMPAT32))) { 4219 private enum enumMixinStr___WORDSIZE_TIME64_COMPAT32 = `enum __WORDSIZE_TIME64_COMPAT32 = 1;`; 4220 static if(is(typeof({ mixin(enumMixinStr___WORDSIZE_TIME64_COMPAT32); }))) { 4221 mixin(enumMixinStr___WORDSIZE_TIME64_COMPAT32); 4222 } 4223 } 4224 4225 4226 4227 4228 static if(!is(typeof(__SYSCALL_WORDSIZE))) { 4229 private enum enumMixinStr___SYSCALL_WORDSIZE = `enum __SYSCALL_WORDSIZE = 64;`; 4230 static if(is(typeof({ mixin(enumMixinStr___SYSCALL_WORDSIZE); }))) { 4231 mixin(enumMixinStr___SYSCALL_WORDSIZE); 4232 } 4233 } 4234 static if(!is(typeof(_SYS_CDEFS_H))) { 4235 private enum enumMixinStr__SYS_CDEFS_H = `enum _SYS_CDEFS_H = 1;`; 4236 static if(is(typeof({ mixin(enumMixinStr__SYS_CDEFS_H); }))) { 4237 mixin(enumMixinStr__SYS_CDEFS_H); 4238 } 4239 } 4240 static if(!is(typeof(__THROW))) { 4241 private enum enumMixinStr___THROW = `enum __THROW = __attribute__ ( ( __nothrow__ ) );`; 4242 static if(is(typeof({ mixin(enumMixinStr___THROW); }))) { 4243 mixin(enumMixinStr___THROW); 4244 } 4245 } 4246 4247 4248 4249 4250 static if(!is(typeof(__THROWNL))) { 4251 private enum enumMixinStr___THROWNL = `enum __THROWNL = __attribute__ ( ( __nothrow__ ) );`; 4252 static if(is(typeof({ mixin(enumMixinStr___THROWNL); }))) { 4253 mixin(enumMixinStr___THROWNL); 4254 } 4255 } 4256 static if(!is(typeof(__ptr_t))) { 4257 private enum enumMixinStr___ptr_t = `enum __ptr_t = void *;`; 4258 static if(is(typeof({ mixin(enumMixinStr___ptr_t); }))) { 4259 mixin(enumMixinStr___ptr_t); 4260 } 4261 } 4262 static if(!is(typeof(__flexarr))) { 4263 private enum enumMixinStr___flexarr = `enum __flexarr = [ ];`; 4264 static if(is(typeof({ mixin(enumMixinStr___flexarr); }))) { 4265 mixin(enumMixinStr___flexarr); 4266 } 4267 } 4268 4269 4270 4271 4272 static if(!is(typeof(__glibc_c99_flexarr_available))) { 4273 private enum enumMixinStr___glibc_c99_flexarr_available = `enum __glibc_c99_flexarr_available = 1;`; 4274 static if(is(typeof({ mixin(enumMixinStr___glibc_c99_flexarr_available); }))) { 4275 mixin(enumMixinStr___glibc_c99_flexarr_available); 4276 } 4277 } 4278 static if(!is(typeof(__attribute_malloc__))) { 4279 private enum enumMixinStr___attribute_malloc__ = `enum __attribute_malloc__ = __attribute__ ( ( __malloc__ ) );`; 4280 static if(is(typeof({ mixin(enumMixinStr___attribute_malloc__); }))) { 4281 mixin(enumMixinStr___attribute_malloc__); 4282 } 4283 } 4284 4285 4286 4287 4288 4289 4290 static if(!is(typeof(__attribute_pure__))) { 4291 private enum enumMixinStr___attribute_pure__ = `enum __attribute_pure__ = __attribute__ ( ( __pure__ ) );`; 4292 static if(is(typeof({ mixin(enumMixinStr___attribute_pure__); }))) { 4293 mixin(enumMixinStr___attribute_pure__); 4294 } 4295 } 4296 4297 4298 4299 4300 static if(!is(typeof(__attribute_const__))) { 4301 private enum enumMixinStr___attribute_const__ = `enum __attribute_const__ = __attribute__ ( cast( __const__ ) );`; 4302 static if(is(typeof({ mixin(enumMixinStr___attribute_const__); }))) { 4303 mixin(enumMixinStr___attribute_const__); 4304 } 4305 } 4306 4307 4308 4309 4310 static if(!is(typeof(__attribute_used__))) { 4311 private enum enumMixinStr___attribute_used__ = `enum __attribute_used__ = __attribute__ ( ( __used__ ) );`; 4312 static if(is(typeof({ mixin(enumMixinStr___attribute_used__); }))) { 4313 mixin(enumMixinStr___attribute_used__); 4314 } 4315 } 4316 4317 4318 4319 4320 static if(!is(typeof(__attribute_noinline__))) { 4321 private enum enumMixinStr___attribute_noinline__ = `enum __attribute_noinline__ = __attribute__ ( ( __noinline__ ) );`; 4322 static if(is(typeof({ mixin(enumMixinStr___attribute_noinline__); }))) { 4323 mixin(enumMixinStr___attribute_noinline__); 4324 } 4325 } 4326 4327 4328 4329 4330 static if(!is(typeof(__attribute_deprecated__))) { 4331 private enum enumMixinStr___attribute_deprecated__ = `enum __attribute_deprecated__ = __attribute__ ( ( __deprecated__ ) );`; 4332 static if(is(typeof({ mixin(enumMixinStr___attribute_deprecated__); }))) { 4333 mixin(enumMixinStr___attribute_deprecated__); 4334 } 4335 } 4336 static if(!is(typeof(__attribute_warn_unused_result__))) { 4337 private enum enumMixinStr___attribute_warn_unused_result__ = `enum __attribute_warn_unused_result__ = __attribute__ ( ( __warn_unused_result__ ) );`; 4338 static if(is(typeof({ mixin(enumMixinStr___attribute_warn_unused_result__); }))) { 4339 mixin(enumMixinStr___attribute_warn_unused_result__); 4340 } 4341 } 4342 4343 4344 4345 4346 4347 4348 static if(!is(typeof(__always_inline))) { 4349 private enum enumMixinStr___always_inline = `enum __always_inline = __inline __attribute__ ( ( __always_inline__ ) );`; 4350 static if(is(typeof({ mixin(enumMixinStr___always_inline); }))) { 4351 mixin(enumMixinStr___always_inline); 4352 } 4353 } 4354 4355 4356 4357 4358 4359 4360 static if(!is(typeof(__extern_inline))) { 4361 private enum enumMixinStr___extern_inline = `enum __extern_inline = extern __inline __attribute__ ( ( __gnu_inline__ ) );`; 4362 static if(is(typeof({ mixin(enumMixinStr___extern_inline); }))) { 4363 mixin(enumMixinStr___extern_inline); 4364 } 4365 } 4366 4367 4368 4369 4370 static if(!is(typeof(__extern_always_inline))) { 4371 private enum enumMixinStr___extern_always_inline = `enum __extern_always_inline = extern __inline __attribute__ ( ( __always_inline__ ) ) __attribute__ ( ( __gnu_inline__ ) );`; 4372 static if(is(typeof({ mixin(enumMixinStr___extern_always_inline); }))) { 4373 mixin(enumMixinStr___extern_always_inline); 4374 } 4375 } 4376 4377 4378 4379 4380 static if(!is(typeof(__fortify_function))) { 4381 private enum enumMixinStr___fortify_function = `enum __fortify_function = extern __inline __attribute__ ( ( __always_inline__ ) ) __attribute__ ( ( __gnu_inline__ ) ) ;`; 4382 static if(is(typeof({ mixin(enumMixinStr___fortify_function); }))) { 4383 mixin(enumMixinStr___fortify_function); 4384 } 4385 } 4386 4387 4388 4389 4390 static if(!is(typeof(__restrict_arr))) { 4391 private enum enumMixinStr___restrict_arr = `enum __restrict_arr = __restrict;`; 4392 static if(is(typeof({ mixin(enumMixinStr___restrict_arr); }))) { 4393 mixin(enumMixinStr___restrict_arr); 4394 } 4395 } 4396 static if(!is(typeof(__HAVE_GENERIC_SELECTION))) { 4397 private enum enumMixinStr___HAVE_GENERIC_SELECTION = `enum __HAVE_GENERIC_SELECTION = 1;`; 4398 static if(is(typeof({ mixin(enumMixinStr___HAVE_GENERIC_SELECTION); }))) { 4399 mixin(enumMixinStr___HAVE_GENERIC_SELECTION); 4400 } 4401 } 4402 4403 4404 4405 4406 static if(!is(typeof(_SYS_SELECT_H))) { 4407 private enum enumMixinStr__SYS_SELECT_H = `enum _SYS_SELECT_H = 1;`; 4408 static if(is(typeof({ mixin(enumMixinStr__SYS_SELECT_H); }))) { 4409 mixin(enumMixinStr__SYS_SELECT_H); 4410 } 4411 } 4412 4413 4414 4415 4416 4417 4418 static if(!is(typeof(__NFDBITS))) { 4419 private enum enumMixinStr___NFDBITS = `enum __NFDBITS = ( 8 * cast( int ) ( __fd_mask ) .sizeof );`; 4420 static if(is(typeof({ mixin(enumMixinStr___NFDBITS); }))) { 4421 mixin(enumMixinStr___NFDBITS); 4422 } 4423 } 4424 static if(!is(typeof(FD_SETSIZE))) { 4425 private enum enumMixinStr_FD_SETSIZE = `enum FD_SETSIZE = 1024;`; 4426 static if(is(typeof({ mixin(enumMixinStr_FD_SETSIZE); }))) { 4427 mixin(enumMixinStr_FD_SETSIZE); 4428 } 4429 } 4430 4431 4432 4433 4434 static if(!is(typeof(NFDBITS))) { 4435 private enum enumMixinStr_NFDBITS = `enum NFDBITS = ( 8 * cast( int ) ( __fd_mask ) .sizeof );`; 4436 static if(is(typeof({ mixin(enumMixinStr_NFDBITS); }))) { 4437 mixin(enumMixinStr_NFDBITS); 4438 } 4439 } 4440 static if(!is(typeof(_SYS_SYSMACROS_H))) { 4441 private enum enumMixinStr__SYS_SYSMACROS_H = `enum _SYS_SYSMACROS_H = 1;`; 4442 static if(is(typeof({ mixin(enumMixinStr__SYS_SYSMACROS_H); }))) { 4443 mixin(enumMixinStr__SYS_SYSMACROS_H); 4444 } 4445 } 4446 static if(!is(typeof(__SYSMACROS_DECL_TEMPL))) { 4447 private enum enumMixinStr___SYSMACROS_DECL_TEMPL = `enum __SYSMACROS_DECL_TEMPL = ( rtype , name , proto ) extern rtype gnu_dev_ ## name proto __attribute__ ( ( __nothrow__ ) ) __attribute__ ( cast( __const__ ) ) ;;`; 4448 static if(is(typeof({ mixin(enumMixinStr___SYSMACROS_DECL_TEMPL); }))) { 4449 mixin(enumMixinStr___SYSMACROS_DECL_TEMPL); 4450 } 4451 } 4452 4453 4454 4455 4456 static if(!is(typeof(__SYSMACROS_IMPL_TEMPL))) { 4457 private enum enumMixinStr___SYSMACROS_IMPL_TEMPL = `enum __SYSMACROS_IMPL_TEMPL = ( rtype , name , proto ) __extension__ extern __inline __attribute__ ( ( __gnu_inline__ ) ) __attribute__ ( cast( __const__ ) ) rtype __attribute__ ( ( __nothrow__ ) ) gnu_dev_ ## name proto;`; 4458 static if(is(typeof({ mixin(enumMixinStr___SYSMACROS_IMPL_TEMPL); }))) { 4459 mixin(enumMixinStr___SYSMACROS_IMPL_TEMPL); 4460 } 4461 } 4462 static if(!is(typeof(_SYS_TYPES_H))) { 4463 private enum enumMixinStr__SYS_TYPES_H = `enum _SYS_TYPES_H = 1;`; 4464 static if(is(typeof({ mixin(enumMixinStr__SYS_TYPES_H); }))) { 4465 mixin(enumMixinStr__SYS_TYPES_H); 4466 } 4467 } 4468 static if(!is(typeof(__BIT_TYPES_DEFINED__))) { 4469 private enum enumMixinStr___BIT_TYPES_DEFINED__ = `enum __BIT_TYPES_DEFINED__ = 1;`; 4470 static if(is(typeof({ mixin(enumMixinStr___BIT_TYPES_DEFINED__); }))) { 4471 mixin(enumMixinStr___BIT_TYPES_DEFINED__); 4472 } 4473 } 4474 } 4475 4476 4477 4478 4479 mixin dpp.EnumD!("AddressMode", WGPUAddressMode, "WGPUAddressMode_"); 4480 mixin dpp.EnumD!("Backend", WGPUBackend, "WGPUBackend_"); 4481 mixin dpp.EnumD!("BindingType", WGPUBindingType, "WGPUBindingType_"); 4482 mixin dpp.EnumD!("BlendFactor", WGPUBlendFactor, "WGPUBlendFactor_"); 4483 mixin dpp.EnumD!("BlendOperation", WGPUBlendOperation, "WGPUBlendOperation_"); 4484 mixin dpp.EnumD!("BufferMapAsyncStatus", WGPUBufferMapAsyncStatus, "WGPUBufferMapAsyncStatus_"); 4485 mixin dpp.EnumD!("CDeviceType", WGPUCDeviceType, "WGPUCDeviceType_"); 4486 mixin dpp.EnumD!("CompareFunction", WGPUCompareFunction, "WGPUCompareFunction_"); 4487 mixin dpp.EnumD!("CullMode", WGPUCullMode, "WGPUCullMode_"); 4488 mixin dpp.EnumD!("FilterMode", WGPUFilterMode, "WGPUFilterMode_"); 4489 mixin dpp.EnumD!("FrontFace", WGPUFrontFace, "WGPUFrontFace_"); 4490 mixin dpp.EnumD!("IndexFormat", WGPUIndexFormat, "WGPUIndexFormat_"); 4491 mixin dpp.EnumD!("InputStepMode", WGPUInputStepMode, "WGPUInputStepMode_"); 4492 mixin dpp.EnumD!("LoadOp", WGPULoadOp, "WGPULoadOp_"); 4493 mixin dpp.EnumD!("LogLevel", WGPULogLevel, "WGPULogLevel_"); 4494 mixin dpp.EnumD!("PowerPreference", WGPUPowerPreference, "WGPUPowerPreference_"); 4495 mixin dpp.EnumD!("PresentMode", WGPUPresentMode, "WGPUPresentMode_"); 4496 mixin dpp.EnumD!("PrimitiveTopology", WGPUPrimitiveTopology, "WGPUPrimitiveTopology_"); 4497 mixin dpp.EnumD!("SType", WGPUSType, "WGPUSType_"); 4498 mixin dpp.EnumD!("StencilOperation", WGPUStencilOperation, "WGPUStencilOperation_"); 4499 mixin dpp.EnumD!("StoreOp", WGPUStoreOp, "WGPUStoreOp_"); 4500 mixin dpp.EnumD!("SwapChainStatus", WGPUSwapChainStatus, "WGPUSwapChainStatus_"); 4501 mixin dpp.EnumD!("TextureAspect", WGPUTextureAspect, "WGPUTextureAspect_"); 4502 mixin dpp.EnumD!("TextureComponentType", WGPUTextureComponentType, "WGPUTextureComponentType_"); 4503 mixin dpp.EnumD!("TextureDimension", WGPUTextureDimension, "WGPUTextureDimension_"); 4504 mixin dpp.EnumD!("TextureFormat", WGPUTextureFormat, "WGPUTextureFormat_"); 4505 mixin dpp.EnumD!("TextureViewDimension", WGPUTextureViewDimension, "WGPUTextureViewDimension_"); 4506 mixin dpp.EnumD!("VertexFormat", WGPUVertexFormat, "WGPUVertexFormat_");