From ebfec37dad4ce209e893d45b01f3b2690bb851d9 Mon Sep 17 00:00:00 2001 From: "The Silk.NET Automaton" <9011267+dotnet-bot@users.noreply.github.com> Date: Sun, 18 Jan 2026 19:04:56 +0000 Subject: [PATCH] Regenerated bindings as of 18/01/2026 (19:04:56) --- build/cache/cl.json.gz | Bin 435337 -> 437524 bytes build/cache/d3d12.json.gz | Bin 389856 -> 389856 bytes build/cache/openxr.json.gz | Bin 248647 -> 248647 bytes build/cache/sdl.json.gz | Bin 194453 -> 194453 bytes build/cache/shaderc.json.gz | Bin 14181 -> 14181 bytes build/cache/spirv-cross.json.gz | Bin 21241 -> 21631 bytes build/cache/spirv-reflect.json.gz | Bin 41903 -> 41903 bytes build/cache/spirv.json.gz | Bin 63012 -> 63012 bytes build/cache/vulkan.json.gz | Bin 473829 -> 474109 bytes build/cache/webgpu.json.gz | Bin 82470 -> 83471 bytes .../Structs/IndirectArgumentDescUnion.gen.cs | 24 +- .../Enums/KHR.gen.cs | 4 + .../LoaderLayers.gen.cs | 51 + .../LoaderLayersOverloads.gen.cs | 84 + src/OpenCL/Silk.NET.OpenCL/CL.gen.cs | 3 + .../Silk.NET.OpenCL/Enums/CLEnum.gen.cs | 4 + .../Silk.NET.OpenCL/Enums/PlatformInfo.gen.cs | 2 + src/SPIRV/Silk.NET.SPIRV.Cross/Cross.gen.cs | 586 +- .../CrossOverloads.gen.cs | 164 +- .../Enums/CompilerOption.gen.cs | 6 + .../Enums/ResourceType.gen.cs | 2 + ...=> AnonymousEnumSpirvReflectL331C1.gen.cs} | 4 +- ...=> AnonymousEnumSpirvReflectL336C1.gen.cs} | 4 +- .../Enums/Generator.gen.cs | 2 + .../Silk.NET.SPIRV.Reflect/Reflect.gen.cs | 892 +-- .../ReflectOverloads.gen.cs | 716 +-- .../Structs/BlockVariable.gen.cs | 4 +- .../Structs/BlockVariableWordOffset.gen.cs | 2 +- .../Structs/DescriptorBinding.gen.cs | 4 +- .../DescriptorBindingWordOffset.gen.cs | 2 +- .../Structs/InterfaceVariable.gen.cs | 12 +- .../InterfaceVariableWordOffset.gen.cs | 2 +- .../Structs/SpecializationConstant.gen.cs | 35 +- .../Structs/TypeDescription.gen.cs | 8 +- src/SPIRV/Silk.NET.SPIRV/Enums/BuiltIn.gen.cs | 24 +- .../Silk.NET.SPIRV/Enums/Capability.gen.cs | 66 + .../Silk.NET.SPIRV/Enums/ComponentType.gen.cs | 48 + .../Enums/CooperativeMatrixReduceMask.gen.cs | 25 + .../Enums/CooperativeMatrixReduceShift.gen.cs | 24 + .../CooperativeVectorMatrixLayout.gen.cs | 26 + .../Silk.NET.SPIRV/Enums/Decoration.gen.cs | 10 + .../Silk.NET.SPIRV/Enums/ExecutionMode.gen.cs | 8 + .../Silk.NET.SPIRV/Enums/FPEncoding.gen.cs | 6 + .../Enums/FunctionControlMask.gen.cs | 2 + .../Enums/FunctionControlShift.gen.cs | 2 + .../Enums/ImageChannelDataType.gen.cs | 12 + ...atrixMultiplyAccumulateOperandsMask.gen.cs | 47 + ...trixMultiplyAccumulateOperandsShift.gen.cs | 46 + src/SPIRV/Silk.NET.SPIRV/Enums/Op.gen.cs | 154 +- .../Silk.NET.SPIRV/Enums/RayFlagsMask.gen.cs | 2 + .../Silk.NET.SPIRV/Enums/RayFlagsShift.gen.cs | 2 + .../Enums/SourceLanguage.gen.cs | 2 + .../Silk.NET.SPIRV/Enums/StorageClass.gen.cs | 4 +- .../Enums/TensorAddressingOperandsMask.gen.cs | 22 + .../TensorAddressingOperandsShift.gen.cs | 22 + .../Enums/TensorClampMode.gen.cs | 28 + .../Enums/TensorOperandsMask.gen.cs | 29 + .../Enums/TensorOperandsShift.gen.cs | 28 + .../Silk.NET.Shaderc/Enums/EnvVersion.gen.cs | 2 + .../Enums/SpirvVersion.gen.cs | 2 +- .../OhosNativeBuffer.gen.cs | 71 - .../OhosNativeBufferOverloads.gen.cs | 49 - .../Silk.NET.Vulkan/Enums/Format.gen.cs | 60 + .../Enums/StructureType.gen.cs | 12 +- ...alDeviceShaderLongVectorFeaturesEXT.gen.cs | 74 + ...DeviceShaderLongVectorPropertiesEXT.gen.cs | 74 + ...TextureCompressionASTC3DFeaturesEXT.gen.cs | 74 + .../Dawn.gen.cs | 728 ++- .../DawnOverloads.gen.cs | 44 +- .../Enums/BufferMapAsyncStatus.gen.cs | 20 +- .../Enums/BufferUsage.gen.cs | 2 +- .../Enums/ColorWriteMask.gen.cs | 2 +- .../Enums/MapMode.gen.cs | 2 +- .../Enums/ShaderStage.gen.cs | 2 +- .../Enums/TextureUsage.gen.cs | 6 +- .../Enums/WGSLFeatureName.gen.cs | 12 +- .../Structs/AdapterProperties.gen.cs | 15 +- .../Structs/ChainedStructOut.gen.cs | 2 +- .../Structs/ComputePassTimestampWrites.gen.cs | 2 +- .../Structs/ImageCopyBuffer.gen.cs | 13 +- .../Structs/ImageCopyTexture.gen.cs | 13 +- .../Structs/PfnErrorCallback.gen.cs | 2 +- .../Structs/PrimitiveDepthClipControl.gen.cs | 2 +- .../ProgrammableStageDescriptor.gen.cs | 2 +- .../RenderPassDescriptorMaxDrawCount.gen.cs | 2 +- .../Structs/RenderPassTimestampWrites.gen.cs | 2 +- .../Structs/RequiredLimits.gen.cs | 2 +- .../ShaderModuleSPIRVDescriptor.gen.cs | 2 +- .../Structs/ShaderModuleWGSLDescriptor.gen.cs | 2 +- .../Structs/SupportedLimits.gen.cs | 2 +- ...ceDescriptorFromAndroidNativeWindow.gen.cs | 2 +- ...aceDescriptorFromCanvasHTMLSelector.gen.cs | 2 +- .../SurfaceDescriptorFromMetalLayer.gen.cs | 2 +- ...SurfaceDescriptorFromWaylandSurface.gen.cs | 2 +- .../SurfaceDescriptorFromWindowsHWND.gen.cs | 2 +- .../SurfaceDescriptorFromXlibWindow.gen.cs | 2 +- .../Structs/TextureDataLayout.gen.cs | 2 +- .../Enums/DxcMaxShaderModel.gen.cs | 34 + .../Enums/GLFenceBehaviour.gen.cs | 22 + .../Enums/InstanceBackend.gen.cs | 37 - .../Enums/InstanceFlag.gen.cs | 27 - .../Enums/NativeFeature.gen.cs | 30 +- .../Enums/NativeSType.gen.cs | 12 +- .../Enums/NativeTextureFormat.gen.cs | 30 + .../Structs/DeviceExtras.gen.cs | 10 +- .../Structs/GlobalReport.gen.cs | 54 +- .../Structs/HubReport.gen.cs | 11 + .../InstanceEnumerateAdapterOptions.gen.cs | 8 +- .../Structs/InstanceExtras.gen.cs | 58 +- .../Structs/NativeLimits.gen.cs | 11 + .../Structs/PfnLogCallback.gen.cs | 12 +- .../Structs/PushConstantRange.gen.cs | 8 +- .../Structs/RegistryReport.gen.cs | 11 - .../Structs/ShaderDefine.gen.cs | 20 +- .../ShaderModuleDescriptorSpirV.gen.cs | 61 + ...criptor.gen.cs => ShaderSourceGLSL.gen.cs} | 20 +- .../Structs/SupportedLimitsExtras.gen.cs | 50 - .../Structs/SurfaceConfigurationExtras.gen.cs | 8 +- ....cs => SurfaceSourceSwapChainPanel.gen.cs} | 20 +- .../Structs/WrappedSubmissionIndex.gen.cs | 50 - .../Wgpu.gen.cs | 96 +- .../WgpuOverloads.gen.cs | 42 +- .../Silk.NET.WebGPU/Enums/AdapterType.gen.cs | 8 +- .../Silk.NET.WebGPU/Enums/AddressMode.gen.cs | 10 +- .../Silk.NET.WebGPU/Enums/BlendFactor.gen.cs | 36 +- .../Enums/BlendOperation.gen.cs | 12 +- .../Enums/BufferBindingType.gen.cs | 10 +- .../Enums/BufferMapState.gen.cs | 6 +- .../Enums/CallbackMode.gen.cs | 2 +- .../Enums/CompareFunction.gen.cs | 14 +- .../Enums/CompilationInfoRequestStatus.gen.cs | 10 +- .../Enums/CompilationMessageType.gen.cs | 6 +- .../Enums/CreatePipelineAsyncStatus.gen.cs | 14 +- .../Silk.NET.WebGPU/Enums/CullMode.gen.cs | 8 +- .../Enums/DeviceLostReason.gen.cs | 4 + .../Silk.NET.WebGPU/Enums/ErrorFilter.gen.cs | 6 +- .../Silk.NET.WebGPU/Enums/ErrorType.gen.cs | 12 +- .../Silk.NET.WebGPU/Enums/FeatureLevel.gen.cs | 24 + .../Silk.NET.WebGPU/Enums/FeatureName.gen.cs | 48 +- .../Silk.NET.WebGPU/Enums/FilterMode.gen.cs | 6 +- .../Silk.NET.WebGPU/Enums/FrontFace.gen.cs | 6 +- .../Enums/InstanceFeatureName.gen.cs | 24 + .../Silk.NET.WebGPU/Enums/LoadOp.gen.cs | 6 +- .../Enums/MapAsyncStatus.gen.cs | 26 + .../Enums/MipmapFilterMode.gen.cs | 6 +- .../Silk.NET.WebGPU/Enums/OptionalBool.gen.cs | 24 + .../Enums/PopErrorScopeStatus.gen.cs | 10 +- .../Enums/PredefinedColorSpace.gen.cs | 22 + .../Silk.NET.WebGPU/Enums/PresentMode.gen.cs | 10 +- .../Enums/PrimitiveTopology.gen.cs | 12 +- .../Silk.NET.WebGPU/Enums/QueryType.gen.cs | 4 +- .../Enums/QueueWorkDoneStatus.gen.cs | 10 +- .../Enums/RequestAdapterStatus.gen.cs | 10 +- .../Enums/RequestDeviceStatus.gen.cs | 8 +- src/WebGPU/Silk.NET.WebGPU/Enums/SType.gen.cs | 61 +- .../Enums/SamplerBindingType.gen.cs | 10 +- .../Enums/Status.gen.cs | 6 +- .../Enums/StencilOperation.gen.cs | 18 +- .../Enums/StorageTextureAccess.gen.cs | 10 +- .../SurfaceGetCurrentTextureStatus.gen.cs | 18 +- .../Enums/TextureAspect.gen.cs | 8 +- .../Enums/TextureDimension.gen.cs | 17 +- .../Enums/TextureFormat.gen.cs | 218 +- .../Enums/TextureSampleType.gen.cs | 14 +- .../Enums/ToneMappingMode.gen.cs | 22 + .../Silk.NET.WebGPU/Enums/VertexFormat.gen.cs | 84 +- .../Enums/VertexStepMode.gen.cs | 8 +- .../Enums/WGSLLanguageFeatureName.gen.cs | 26 + .../Enums/WaitStatus.gen.cs | 16 +- .../Structs/AdapterInfo.gen.cs | 117 +- .../Structs/BindGroupDescriptor.gen.cs | 14 +- .../Structs/BindGroupEntry.gen.cs | 4 +- .../Structs/BindGroupLayoutDescriptor.gen.cs | 14 +- .../Structs/BindGroupLayoutEntry.gen.cs | 23 +- .../Structs/BufferBindingLayout.gen.cs | 4 +- .../Structs/BufferDescriptor.gen.cs | 22 +- .../Structs/BufferMapCallbackInfo.gen.cs | 27 +- .../Structs/ChainedStruct.gen.cs | 4 +- .../Structs/ColorTargetState.gen.cs | 12 +- .../Structs/CommandBufferDescriptor.gen.cs | 14 +- .../Structs/CommandEncoderDescriptor.gen.cs | 14 +- .../Structs/CompilationInfo.gen.cs | 4 +- .../CompilationInfoCallbackInfo.gen.cs | 27 +- .../Structs/CompilationMessage.gen.cs | 49 +- .../Structs/ComputePassDescriptor.gen.cs | 22 +- .../Structs/ComputePipelineDescriptor.gen.cs | 22 +- .../Structs/ComputeState.gen.cs | 83 + .../Structs/ConstantEntry.gen.cs | 14 +- ...ateComputePipelineAsyncCallbackInfo.gen.cs | 27 +- ...eateRenderPipelineAsyncCallbackInfo.gen.cs | 27 +- .../Structs/DepthStencilState.gen.cs | 12 +- .../Structs/DeviceDescriptor.gen.cs | 50 +- .../Structs/DeviceLostCallbackInfo.gen.cs | 35 +- .../Structs/FragmentState.gen.cs | 14 +- .../Structs/Future.gen.cs | 2 +- .../Structs/FutureWaitInfo.gen.cs | 2 +- .../Structs/InstanceDescriptor.gen.cs | 39 +- .../Structs/InstanceLimits.gen.cs | 50 + .../Silk.NET.WebGPU/Structs/Limits.gen.cs | 35 +- .../Structs/MultisampleState.gen.cs | 4 +- .../Structs/PassTimestampWrites.gen.cs | 72 + ...fnAdapterRequestAdapterInfoCallback.gen.cs | 53 - .../Structs/PfnBufferMapCallback.gen.cs | 12 +- .../Structs/PfnCompilationInfoCallback.gen.cs | 12 +- ...nCreateComputePipelineAsyncCallback.gen.cs | 12 +- ...fnCreateRenderPipelineAsyncCallback.gen.cs | 12 +- .../Structs/PfnDeviceLostCallback.gen.cs | 12 +- .../Structs/PfnPopErrorScopeCallback.gen.cs | 14 +- .../Structs/PfnQueueWorkDoneCallback.gen.cs | 12 +- .../Structs/PfnRequestAdapterCallback.gen.cs | 12 +- .../Structs/PfnRequestDeviceCallback.gen.cs | 12 +- .../Structs/PfnUncapturedErrorCallback.gen.cs | 53 + .../Structs/PipelineLayoutDescriptor.gen.cs | 27 +- .../Structs/PopErrorScopeCallbackInfo.gen.cs | 30 +- .../Structs/PrimitiveState.gen.cs | 17 +- .../Structs/QuerySetDescriptor.gen.cs | 14 +- .../Structs/QueueDescriptor.gen.cs | 14 +- .../Structs/QueueWorkDoneCallbackInfo.gen.cs | 27 +- .../Structs/RenderBundleDescriptor.gen.cs | 14 +- .../RenderBundleEncoderDescriptor.gen.cs | 14 +- .../Structs/RenderPassColorAttachment.gen.cs | 4 +- .../RenderPassDepthStencilAttachment.gen.cs | 11 + .../Structs/RenderPassDescriptor.gen.cs | 22 +- .../Structs/RenderPassMaxDrawCount.gen.cs | 50 + .../Structs/RenderPipelineDescriptor.gen.cs | 14 +- .../Structs/RequestAdapterCallbackInfo.gen.cs | 27 +- .../Structs/RequestAdapterOptions.gen.cs | 43 +- .../Structs/RequestAdapterWebXROptions.gen.cs | 50 + .../Structs/RequestDeviceCallbackInfo.gen.cs | 27 +- .../Structs/SamplerBindingLayout.gen.cs | 4 +- .../Structs/SamplerDescriptor.gen.cs | 14 +- .../ShaderModuleCompilationHint.gen.cs | 61 - .../Structs/ShaderModuleDescriptor.gen.cs | 36 +- .../Structs/ShaderSourceSPIRV.gen.cs | 61 + .../Structs/ShaderSourceWGSL.gen.cs | 50 + .../StorageTextureBindingLayout.gen.cs | 4 +- .../Silk.NET.WebGPU/Structs/StringView.gen.cs | 50 + .../Structs/SupportedFeatures.gen.cs | 50 + .../Structs/SupportedInstanceFeatures.gen.cs | 50 + .../SupportedWGSLLanguageFeatures.gen.cs | 50 + .../Structs/SurfaceCapabilities.gen.cs | 19 +- .../Structs/SurfaceColorManagement.gen.cs | 61 + .../Structs/SurfaceConfiguration.gen.cs | 56 +- .../Structs/SurfaceDescriptor.gen.cs | 14 +- .../SurfaceSourceAndroidNativeWindow.gen.cs | 50 + .../Structs/SurfaceSourceMetalLayer.gen.cs | 50 + .../SurfaceSourceWaylandSurface.gen.cs | 61 + .../Structs/SurfaceSourceWindowsHWND.gen.cs | 61 + ...w.gen.cs => SurfaceSourceXCBWindow.gen.cs} | 6 +- .../Structs/SurfaceSourceXlibWindow.gen.cs | 61 + .../Structs/SurfaceTexture.gen.cs | 20 +- .../Structs/TexelCopyBufferInfo.gen.cs | 50 + .../Structs/TexelCopyBufferLayout.gen.cs | 61 + .../Structs/TexelCopyTextureInfo.gen.cs | 72 + .../Structs/TextureBindingLayout.gen.cs | 4 +- .../Structs/TextureDescriptor.gen.cs | 22 +- .../Structs/TextureViewDescriptor.gen.cs | 27 +- .../UncapturedErrorCallbackInfo.gen.cs | 35 +- .../Structs/VertexAttribute.gen.cs | 11 + .../Structs/VertexBufferLayout.gen.cs | 25 +- .../Structs/VertexState.gen.cs | 14 +- src/WebGPU/Silk.NET.WebGPU/WebGPU.gen.cs | 1360 ++--- .../Silk.NET.WebGPU/WebGPUOverloads.gen.cs | 586 +- .../Silk.NET.SDL/Enums/AssertState.gen.cs | 2 +- .../Silk.NET.SDL/Enums/AudioStatus.gen.cs | 2 +- .../Silk.NET.SDL/Enums/BlendFactor.gen.cs | 1 - .../Silk.NET.SDL/Enums/BlendMode.gen.cs | 1 - .../Silk.NET.SDL/Enums/BlendOperation.gen.cs | 1 - .../Silk.NET.SDL/Enums/DUMMYENUM.gen.cs | 19 + .../Silk.NET.SDL/Enums/DisplayEventID.gen.cs | 1 - .../Enums/DisplayOrientation.gen.cs | 1 - .../Silk.NET.SDL/Enums/EventType.gen.cs | 1 - .../Silk.NET.SDL/Enums/Eventaction.gen.cs | 1 - .../Silk.NET.SDL/Enums/FlashOperation.gen.cs | 1 - .../Enums/GLContextResetNotification.gen.cs | 1 - .../Silk.NET.SDL/Enums/GLattr.gen.cs | 1 - .../Silk.NET.SDL/Enums/GLcontextFlag.gen.cs | 1 - .../Enums/GLcontextReleaseFlag.gen.cs | 1 - .../Silk.NET.SDL/Enums/GLprofile.gen.cs | 1 - .../Enums/GameControllerAxis.gen.cs | 1 - .../Enums/GameControllerBindType.gen.cs | 1 - .../Enums/GameControllerButton.gen.cs | 1 - .../Enums/GameControllerType.gen.cs | 1 - .../Silk.NET.SDL/Enums/HintPriority.gen.cs | 1 - .../Silk.NET.SDL/Enums/HitTestResult.gen.cs | 1 - .../Enums/JoystickPowerLevel.gen.cs | 2 +- .../Silk.NET.SDL/Enums/JoystickType.gen.cs | 2 +- .../Silk.NET.SDL/Enums/KeyCode.gen.cs | 1 - .../Silk.NET.SDL/Enums/Keymod.gen.cs | 1 - .../Silk.NET.SDL/Enums/LogCategory.gen.cs | 1 - .../Silk.NET.SDL/Enums/LogPriority.gen.cs | 1 - .../Enums/MessageBoxButtonFlags.gen.cs | 1 - .../Enums/MessageBoxColorType.gen.cs | 1 - .../Silk.NET.SDL/Enums/MessageBoxFlags.gen.cs | 1 - .../Enums/MouseWheelDirection.gen.cs | 1 - .../Silk.NET.SDL/Enums/PowerState.gen.cs | 1 - .../Silk.NET.SDL/Enums/RendererFlags.gen.cs | 1 - .../Silk.NET.SDL/Enums/RendererFlip.gen.cs | 1 - .../Silk.NET.SDL/Enums/ScaleMode.gen.cs | 1 - .../Silk.NET.SDL/Enums/Scancode.gen.cs | 1 - .../Silk.NET.SDL/Enums/SdlBool.gen.cs | 2 +- .../Silk.NET.SDL/Enums/SensorType.gen.cs | 1 - .../Silk.NET.SDL/Enums/SystemCursor.gen.cs | 1 - .../Silk.NET.SDL/Enums/TextureAccess.gen.cs | 1 - .../Silk.NET.SDL/Enums/TextureModulate.gen.cs | 1 - .../Silk.NET.SDL/Enums/ThreadPriority.gen.cs | 1 - .../Enums/WinRTDeviceFamily.gen.cs | 1 - .../Silk.NET.SDL/Enums/WinRTPath.gen.cs | 1 - .../Silk.NET.SDL/Enums/WindowEventID.gen.cs | 1 - .../Silk.NET.SDL/Enums/WindowFlags.gen.cs | 1 - .../Enums/YUVCONVERSIONMODE.gen.cs | 37 - src/Windowing/Silk.NET.SDL/Sdl.gen.cs | 5077 +++++++++-------- .../Silk.NET.SDL/SdlOverloads.gen.cs | 2576 ++++----- .../Silk.NET.SDL/Structs/AtomicT.gen.cs | 1 - .../Silk.NET.SDL/Structs/DisplayMode.gen.cs | 1 - .../Silk.NET.SDL/Structs/GUID.gen.cs | 28 - .../Structs/GameControllerButtonBind.gen.cs | 4 +- .../GameControllerButtonBindValue.gen.cs | 6 +- .../GameControllerButtonBindValueHat.gen.cs | 2 +- .../Structs/MessageBoxButtonData.gen.cs | 1 - .../Structs/MessageBoxColor.gen.cs | 1 - .../Structs/MessageBoxColorScheme.gen.cs | 1 - .../Structs/MessageBoxData.gen.cs | 1 - .../Structs/PfnCompareCallback.gen.cs | 53 + .../Silk.NET.SDL/Structs/PfnVvVvI.gen.cs | 53 - 325 files changed, 10738 insertions(+), 8071 deletions(-) rename src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/{AnonymousEnumSpirvReflectL330C1.gen.cs => AnonymousEnumSpirvReflectL331C1.gen.cs} (81%) rename src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/{AnonymousEnumSpirvReflectL335C1.gen.cs => AnonymousEnumSpirvReflectL336C1.gen.cs} (82%) create mode 100644 src/SPIRV/Silk.NET.SPIRV/Enums/ComponentType.gen.cs create mode 100644 src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeMatrixReduceMask.gen.cs create mode 100644 src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeMatrixReduceShift.gen.cs create mode 100644 src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeVectorMatrixLayout.gen.cs create mode 100644 src/SPIRV/Silk.NET.SPIRV/Enums/MatrixMultiplyAccumulateOperandsMask.gen.cs create mode 100644 src/SPIRV/Silk.NET.SPIRV/Enums/MatrixMultiplyAccumulateOperandsShift.gen.cs create mode 100644 src/SPIRV/Silk.NET.SPIRV/Enums/TensorAddressingOperandsMask.gen.cs create mode 100644 src/SPIRV/Silk.NET.SPIRV/Enums/TensorAddressingOperandsShift.gen.cs create mode 100644 src/SPIRV/Silk.NET.SPIRV/Enums/TensorClampMode.gen.cs create mode 100644 src/SPIRV/Silk.NET.SPIRV/Enums/TensorOperandsMask.gen.cs create mode 100644 src/SPIRV/Silk.NET.SPIRV/Enums/TensorOperandsShift.gen.cs delete mode 100644 src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.OHOS/OhosNativeBuffer.gen.cs delete mode 100644 src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.OHOS/OhosNativeBufferOverloads.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderLongVectorFeaturesEXT.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderLongVectorPropertiesEXT.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceTextureCompressionASTC3DFeaturesEXT.gen.cs rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Enums/BufferMapAsyncStatus.gen.cs (73%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Enums/BufferUsage.gen.cs (96%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Enums/ColorWriteMask.gen.cs (95%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Enums/MapMode.gen.cs (93%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Enums/ShaderStage.gen.cs (94%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Enums/TextureUsage.gen.cs (78%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Enums/WGSLFeatureName.gen.cs (59%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/AdapterProperties.gen.cs (88%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/ChainedStructOut.gen.cs (96%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/ComputePassTimestampWrites.gen.cs (97%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/ImageCopyBuffer.gen.cs (75%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/ImageCopyTexture.gen.cs (82%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/PfnErrorCallback.gen.cs (98%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/PrimitiveDepthClipControl.gen.cs (96%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/ProgrammableStageDescriptor.gen.cs (98%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/RenderPassDescriptorMaxDrawCount.gen.cs (96%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/RenderPassTimestampWrites.gen.cs (97%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/RequiredLimits.gen.cs (96%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/ShaderModuleSPIRVDescriptor.gen.cs (97%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/ShaderModuleWGSLDescriptor.gen.cs (96%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/SupportedLimits.gen.cs (96%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/SurfaceDescriptorFromAndroidNativeWindow.gen.cs (96%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/SurfaceDescriptorFromCanvasHTMLSelector.gen.cs (96%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/SurfaceDescriptorFromMetalLayer.gen.cs (96%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/SurfaceDescriptorFromWaylandSurface.gen.cs (97%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/SurfaceDescriptorFromWindowsHWND.gen.cs (97%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/SurfaceDescriptorFromXlibWindow.gen.cs (97%) rename src/WebGPU/{Silk.NET.WebGPU => Extensions/Silk.NET.WebGPU.Extensions.Dawn}/Structs/TextureDataLayout.gen.cs (97%) create mode 100644 src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/DxcMaxShaderModel.gen.cs create mode 100644 src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/GLFenceBehaviour.gen.cs delete mode 100644 src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/InstanceBackend.gen.cs delete mode 100644 src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/InstanceFlag.gen.cs create mode 100644 src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeTextureFormat.gen.cs create mode 100644 src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderModuleDescriptorSpirV.gen.cs rename src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/{ShaderModuleGLSLDescriptor.gen.cs => ShaderSourceGLSL.gen.cs} (81%) delete mode 100644 src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/SupportedLimitsExtras.gen.cs rename src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/{RequiredLimitsExtras.gen.cs => SurfaceSourceSwapChainPanel.gen.cs} (66%) delete mode 100644 src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/WrappedSubmissionIndex.gen.cs rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Enums/CallbackMode.gen.cs (94%) create mode 100644 src/WebGPU/Silk.NET.WebGPU/Enums/FeatureLevel.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Enums/InstanceFeatureName.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Enums/MapAsyncStatus.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Enums/OptionalBool.gen.cs rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Enums/PopErrorScopeStatus.gen.cs (66%) create mode 100644 src/WebGPU/Silk.NET.WebGPU/Enums/PredefinedColorSpace.gen.cs rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Enums/Status.gen.cs (84%) create mode 100644 src/WebGPU/Silk.NET.WebGPU/Enums/ToneMappingMode.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Enums/WGSLLanguageFeatureName.gen.cs rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Enums/WaitStatus.gen.cs (51%) rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/BufferMapCallbackInfo.gen.cs (72%) rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/CompilationInfoCallbackInfo.gen.cs (73%) create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/ComputeState.gen.cs rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/CreateComputePipelineAsyncCallbackInfo.gen.cs (74%) rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/CreateRenderPipelineAsyncCallbackInfo.gen.cs (74%) rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/DeviceLostCallbackInfo.gen.cs (63%) rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/Future.gen.cs (95%) rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/FutureWaitInfo.gen.cs (96%) create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/InstanceLimits.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/PassTimestampWrites.gen.cs delete mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/PfnAdapterRequestAdapterInfoCallback.gen.cs rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/PfnPopErrorScopeCallback.gen.cs (75%) create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/PfnUncapturedErrorCallback.gen.cs rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/PopErrorScopeCallbackInfo.gen.cs (71%) rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/QueueWorkDoneCallbackInfo.gen.cs (73%) create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassMaxDrawCount.gen.cs rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/RequestAdapterCallbackInfo.gen.cs (73%) create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/RequestAdapterWebXROptions.gen.cs rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/RequestDeviceCallbackInfo.gen.cs (73%) delete mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleCompilationHint.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/ShaderSourceSPIRV.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/ShaderSourceWGSL.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/StringView.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/SupportedFeatures.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/SupportedInstanceFeatures.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/SupportedWGSLLanguageFeatures.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceColorManagement.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceAndroidNativeWindow.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceMetalLayer.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceWaylandSurface.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceWindowsHWND.gen.cs rename src/WebGPU/Silk.NET.WebGPU/Structs/{SurfaceDescriptorFromXcbWindow.gen.cs => SurfaceSourceXCBWindow.gen.cs} (89%) create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceXlibWindow.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyBufferInfo.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyBufferLayout.gen.cs create mode 100644 src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyTextureInfo.gen.cs rename src/WebGPU/{Extensions/Silk.NET.WebGPU.Extensions.Dawn => Silk.NET.WebGPU}/Structs/UncapturedErrorCallbackInfo.gen.cs (57%) create mode 100644 src/Windowing/Silk.NET.SDL/Enums/DUMMYENUM.gen.cs delete mode 100644 src/Windowing/Silk.NET.SDL/Enums/YUVCONVERSIONMODE.gen.cs delete mode 100644 src/Windowing/Silk.NET.SDL/Structs/GUID.gen.cs create mode 100644 src/Windowing/Silk.NET.SDL/Structs/PfnCompareCallback.gen.cs delete mode 100644 src/Windowing/Silk.NET.SDL/Structs/PfnVvVvI.gen.cs diff --git a/build/cache/cl.json.gz b/build/cache/cl.json.gz index 3d1922f1e3ae2bbc79fe4a83b5c557169a8e6db1..dfcbfe1eb75ab4bcade56d67320ba3d25a7e1e73 100644 GIT binary patch literal 437524 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 %z++@*yrG)Rpgv#t(4{ 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≺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 BhARL7 literal 435337 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℘s8T4WM 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%0DKfVyQWX|By4((2qwi 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�&{%Ee<3sa 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ΜH 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 W+)JRKpgcUFqm(lbRZ(ilq5c;l|45?% diff --git a/build/cache/d3d12.json.gz b/build/cache/d3d12.json.gz index f80932ce14d6109efa626312bbc9c78cf56e5f0e..5ac2e5e76f613998e0ff5e06cbd3060bdac218c8 100644 GIT binary patch delta 228474 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%0AkQ?mJg`GvTKT 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%0Ar z5K0Nw9KoY8w9;}dz#9rjl9RY)EbKqDqCRj4B{H|H`Mgf!fH2~FUn|6=*~&t{P@|j} zeB>W$IF_N2ehXrk;5fbQ`?mC(Wqe}7*PQG!SwZ9^C0J?uLZ5#J7wLq!E^a~sLCH0U z31zoGB99OR%lN5&;Y5bz#MDm6a%yl|4oQw$67zM9(Wp&U!?)pL>4DOT?r90I4AI&; zVYc7)Gn>p~o4TAFR@37e$6uK7fnARi!vzLIKS6A_-$L{!(r+%&D(W+k4*%m;SyWjL zMg~{m@aD2Ogp*FI$%l6CvOrP4d0GN$bXSdu-kRiP zb*om;b5?+Y}>YN+qSE^Y+GHnZQHi( zsxI5MJ=M>=@5G%uF)?vtKK(Pl<;loAXRr0!d!1mo#XALFI=l!^as}fXxkkcQjSnP2 z(i_>Ix-)-kjA8Ei{La44$%@NODWaPELL|%NAbo*^V9VSR3->jJ}`0`@!N^b&ePy9xX) zq;|r5=Vzk8sFrN7ko_RApKAHVf?Kmxq}I1q_uZgoVU&*{T+xV^fF1@MUN)x%%6D4v zPl?sf6)>%h$Wq4YCTZHD%2@FjnsMLUW6=Giqb8#x!KlVeYt2uOOr|7#mOm{H_C3MQ zz_Bf{yuousdj2?x=M~8`4#PI*ylQ0*|KB9lmh3K21?5_BTr#G7C#=Ycl3Q|+qY!*RAe@f*kKJdO(!x|2n*x}&XYC9m>tNOqE@;Zx zG)5vBPlrT9h(TNs_=|8!!)3OyvKBuEi-hVf=zpiERhtPy>GSnYgMIv#FB#Y%=j~cc zTe7%fM@0yX*n~@$ot~2v9)o#|{^VNnC~6-hM_~ z4!HX8;Z%g}0BR==_B?J-aCP4G1$C}DkJ(}W3dd||V5&8xJM|Jwtg{S&W?VSn*D2~$u? zn>b^z^5lwu+H5@rs=w7p_{A}~{≷YlrwVqz2`x4E(*iNmbmO8xhccwFK?Svu@oI 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 z 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 diff --git a/build/cache/sdl.json.gz b/build/cache/sdl.json.gz index 8557329a53c2757290b161206d30c8b9e79f8a07..45c65d0d88c83fa0758800635575d0ea41410014 100644 GIT binary patch delta 177859 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 ^?RdF)<)ite?BKPSu-2@nDGO`RALy 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

Js3F(=A<^d{sVM%Vzq4To;zkF-)j3@vAWy@ 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

r-CpAX>aQe@fB7rH@8!%KJ#Zzo_oc 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

EJU_m4XZZrtFmkE26hqL_v6OML^q1 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

|!Lr>+Nq5 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%0D|M81* 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 diff --git a/build/cache/webgpu.json.gz b/build/cache/webgpu.json.gz index 91dd1d44306c63c840d743bd2fd1c37f1db4236b..01e68e27dd975c3d98bca884ec48e2da9da60e82 100644 GIT binary patch literal 83471 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 J*FypHe*jli0zd!& literal 82470 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⁣W*NBxrT&*i=SEB?l${A3_^u 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 { public const string ExtensionName = "LOADER_layers"; + [NativeApi(EntryPoint = "clDeinitLayer", Convention = CallingConvention.Winapi)] + public partial int DeinitLayer(); + [NativeApi(EntryPoint = "clGetLayerInfo", Convention = CallingConvention.Winapi)] public unsafe partial int GetLayerInfo([Flow(Silk.NET.Core.Native.FlowDirection.In)] LayerInfo param_name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] nuint param_value_size, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] void* param_value, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] nuint* param_value_size_ret); @@ -72,6 +75,54 @@ public unsafe partial class LoaderLayers : NativeExtension [NativeApi(EntryPoint = "clInitLayer", Convention = CallingConvention.Winapi)] public unsafe partial int InitLayer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] out uint num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret) where T0 : unmanaged; + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties); + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ulong properties); + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties); + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ulong properties); + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] out uint num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties); + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] out uint num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ulong properties); + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] out uint num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties); + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] out uint num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ulong properties); + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties) where T0 : unmanaged; + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ulong properties) where T0 : unmanaged; + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties) where T0 : unmanaged; + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ulong properties) where T0 : unmanaged; + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] out uint num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties) where T0 : unmanaged; + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] out uint num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ulong properties) where T0 : unmanaged; + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] out uint num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties) where T0 : unmanaged; + + [NativeApi(EntryPoint = "clInitLayerWithProperties", Convention = CallingConvention.Winapi)] + public unsafe partial int InitLayerWithProperties([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] out uint num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ulong properties) where T0 : unmanaged; + public LoaderLayers(INativeContext ctx) : base(ctx) { diff --git a/src/OpenCL/Extensions/Silk.NET.OpenCL.Extensions.LOADER/LoaderLayersOverloads.gen.cs b/src/OpenCL/Extensions/Silk.NET.OpenCL.Extensions.LOADER/LoaderLayersOverloads.gen.cs index 6f3d7afde4..811f1d0188 100644 --- a/src/OpenCL/Extensions/Silk.NET.OpenCL.Extensions.LOADER/LoaderLayersOverloads.gen.cs +++ b/src/OpenCL/Extensions/Silk.NET.OpenCL.Extensions.LOADER/LoaderLayersOverloads.gen.cs @@ -91,6 +91,90 @@ public static unsafe int InitLayer(this LoaderLayers thisApi, [Flow(Silk.NET return thisApi.InitLayer(num_entries, in target_dispatch.GetPinnableReference(), out num_entries_ret.GetPinnableReference(), in layer_dispatch_ret); } + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan properties) + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, target_dispatch, num_entries_ret, layer_dispatch_ret, in properties.GetPinnableReference()); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan properties) + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, target_dispatch, num_entries_ret, in layer_dispatch_ret, in properties.GetPinnableReference()); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties) + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, target_dispatch, out num_entries_ret.GetPinnableReference(), layer_dispatch_ret, properties); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan properties) + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, target_dispatch, out num_entries_ret.GetPinnableReference(), layer_dispatch_ret, in properties.GetPinnableReference()); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties) + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, target_dispatch, out num_entries_ret.GetPinnableReference(), in layer_dispatch_ret, properties); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan properties) + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, target_dispatch, out num_entries_ret.GetPinnableReference(), in layer_dispatch_ret, in properties.GetPinnableReference()); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties) where T0 : unmanaged + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, in target_dispatch.GetPinnableReference(), num_entries_ret, layer_dispatch_ret, properties); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan properties) where T0 : unmanaged + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, in target_dispatch.GetPinnableReference(), num_entries_ret, layer_dispatch_ret, in properties.GetPinnableReference()); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties) where T0 : unmanaged + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, in target_dispatch.GetPinnableReference(), num_entries_ret, in layer_dispatch_ret, properties); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan properties) where T0 : unmanaged + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, in target_dispatch.GetPinnableReference(), num_entries_ret, in layer_dispatch_ret, in properties.GetPinnableReference()); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties) where T0 : unmanaged + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, in target_dispatch.GetPinnableReference(), out num_entries_ret.GetPinnableReference(), layer_dispatch_ret, properties); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void** layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan properties) where T0 : unmanaged + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, in target_dispatch.GetPinnableReference(), out num_entries_ret.GetPinnableReference(), layer_dispatch_ret, in properties.GetPinnableReference()); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* properties) where T0 : unmanaged + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, in target_dispatch.GetPinnableReference(), out num_entries_ret.GetPinnableReference(), in layer_dispatch_ret, properties); + } + + public static unsafe int InitLayerWithProperties(this LoaderLayers thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint num_entries, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan target_dispatch, [Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span num_entries_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly void* layer_dispatch_ret, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan properties) where T0 : unmanaged + { + // SpanOverloader + return thisApi.InitLayerWithProperties(num_entries, in target_dispatch.GetPinnableReference(), out num_entries_ret.GetPinnableReference(), in layer_dispatch_ret, in properties.GetPinnableReference()); + } + } } diff --git a/src/OpenCL/Silk.NET.OpenCL/CL.gen.cs b/src/OpenCL/Silk.NET.OpenCL/CL.gen.cs index e76fd51d94..032bd546ec 100644 --- a/src/OpenCL/Silk.NET.OpenCL/CL.gen.cs +++ b/src/OpenCL/Silk.NET.OpenCL/CL.gen.cs @@ -140,6 +140,9 @@ public unsafe partial class CL : NativeAPI [NativeName("Name", "CL_LAYER_API_VERSION_100")] public const int LayerApiVersion100 = unchecked((int) 100); [NativeName("Type", "")] + [NativeName("Name", "CL_LAYER_PROPERTIES_LIST_END")] + public const int LayerPropertiesListEnd = unchecked((int) ((cl_layer_properties)0)); + [NativeName("Type", "")] [NativeName("Name", "CL_LONG_MAX")] public const long LongMax = unchecked((long) long.MaxValue); [NativeName("Type", "")] diff --git a/src/OpenCL/Silk.NET.OpenCL/Enums/CLEnum.gen.cs b/src/OpenCL/Silk.NET.OpenCL/Enums/CLEnum.gen.cs index 3110e2498d..b00773d8a4 100644 --- a/src/OpenCL/Silk.NET.OpenCL/Enums/CLEnum.gen.cs +++ b/src/OpenCL/Silk.NET.OpenCL/Enums/CLEnum.gen.cs @@ -2372,6 +2372,10 @@ public enum CLEnum : int IcdSuffixKhr = 0x920, [NativeName("Name", "CL_PLATFORM_ICD_SUFFIX_KHR")] PlatformIcdSuffixKhr = 0x920, + [NativeName("Name", "CL_PLATFORM_UNLOADABLE_KHR")] + UnloadableKhr = 0x921, + [NativeName("Name", "CL_PLATFORM_UNLOADABLE_KHR")] + PlatformUnloadableKhr = 0x921, [NativeName("Name", "CL_PLATFORM_NUMERIC_VERSION_KHR")] PlatformNumericVersionKhr = 0x906, [NativeName("Name", "CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR")] diff --git a/src/OpenCL/Silk.NET.OpenCL/Enums/PlatformInfo.gen.cs b/src/OpenCL/Silk.NET.OpenCL/Enums/PlatformInfo.gen.cs index f1c3cf7553..96f12553cc 100644 --- a/src/OpenCL/Silk.NET.OpenCL/Enums/PlatformInfo.gen.cs +++ b/src/OpenCL/Silk.NET.OpenCL/Enums/PlatformInfo.gen.cs @@ -30,6 +30,8 @@ public enum PlatformInfo : int ExtensionsWithVersion = 0x907, [NativeName("Name", "CL_PLATFORM_ICD_SUFFIX_KHR")] IcdSuffixKhr = 0x920, + [NativeName("Name", "CL_PLATFORM_UNLOADABLE_KHR")] + UnloadableKhr = 0x921, [NativeName("Name", "CL_PLATFORM_NUMERIC_VERSION_KHR")] NumericVersionKhr = 0x906, [NativeName("Name", "CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR")] diff --git a/src/SPIRV/Silk.NET.SPIRV.Cross/Cross.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Cross/Cross.gen.cs index d4461fb5c9..df0f493c9d 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Cross/Cross.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Cross/Cross.gen.cs @@ -21,7 +21,7 @@ public unsafe partial class Cross : NativeAPI public const int CApiVersionMajor = unchecked((int) 0x0); [NativeName("Type", "int")] [NativeName("Name", "SPVC_C_API_VERSION_MINOR")] - public const int CApiVersionMinor = unchecked((int) 0x40); + public const int CApiVersionMinor = unchecked((int) 0x44); [NativeName("Type", "int")] [NativeName("Name", "SPVC_C_API_VERSION_PATCH")] public const int CApiVersionPatch = unchecked((int) 0x0); @@ -105,1473 +105,1473 @@ public unsafe partial class Cross : NativeAPI public partial string GetCommitRevisionAndTimestampS(); ///

To be documented. - [NativeName("Src", "Line 338, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 339, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_vertex_attribute_init")] public unsafe partial void MslVertexAttributeInit(MslVertexAttribute* attr); /// To be documented. - [NativeName("Src", "Line 338, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 339, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_vertex_attribute_init")] public partial void MslVertexAttributeInit(ref MslVertexAttribute attr); /// To be documented. - [NativeName("Src", "Line 353, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 354, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_shader_interface_var_init")] public unsafe partial void MslShaderInterfaceVarInit(MslShaderInterfaceVar* var); /// To be documented. - [NativeName("Src", "Line 353, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 354, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_shader_interface_var_init")] public partial void MslShaderInterfaceVarInit(ref MslShaderInterfaceVar var); /// To be documented. - [NativeName("Src", "Line 357, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 358, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_shader_input_init")] public unsafe partial void MslShaderInputInit(MslShaderInterfaceVar* input); /// To be documented. - [NativeName("Src", "Line 357, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 358, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_shader_input_init")] public partial void MslShaderInputInit(ref MslShaderInterfaceVar input); /// To be documented. - [NativeName("Src", "Line 382, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 383, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_shader_interface_var_init_2")] public unsafe partial void MslShaderInterfaceVarInit2(MslShaderInterfaceVar2* var); /// To be documented. - [NativeName("Src", "Line 382, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 383, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_shader_interface_var_init_2")] public partial void MslShaderInterfaceVarInit2(ref MslShaderInterfaceVar2 var); /// To be documented. - [NativeName("Src", "Line 412, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 413, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_resource_binding_init")] public unsafe partial void MslResourceBindingInit(MslResourceBinding* binding); /// To be documented. - [NativeName("Src", "Line 412, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 413, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_resource_binding_init")] public partial void MslResourceBindingInit(ref MslResourceBinding binding); /// To be documented. - [NativeName("Src", "Line 413, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 414, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_resource_binding_init_2")] public unsafe partial void MslResourceBindingInit2(MslResourceBinding2* binding); /// To be documented. - [NativeName("Src", "Line 413, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 414, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_resource_binding_init_2")] public partial void MslResourceBindingInit2(ref MslResourceBinding2 binding); /// To be documented. - [NativeName("Src", "Line 425, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 426, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_get_aux_buffer_struct_version")] public partial uint MslGetAuxBufferStructVersion(); /// To be documented. - [NativeName("Src", "Line 560, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 561, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_constexpr_sampler_init")] public unsafe partial void MslConstexprSamplerInit(MslConstexprSampler* sampler); /// To be documented. - [NativeName("Src", "Line 560, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 561, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_constexpr_sampler_init")] public partial void MslConstexprSamplerInit(ref MslConstexprSampler sampler); /// To be documented. - [NativeName("Src", "Line 580, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 581, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_sampler_ycbcr_conversion_init")] public unsafe partial void MslSamplerYcbcrConversionInit(MslSamplerYcbcrConversion* conv); /// To be documented. - [NativeName("Src", "Line 580, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 581, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_msl_sampler_ycbcr_conversion_init")] public partial void MslSamplerYcbcrConversionInit(ref MslSamplerYcbcrConversion conv); /// To be documented. - [NativeName("Src", "Line 618, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 619, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_hlsl_resource_binding_init")] public unsafe partial void HlslResourceBindingInit(HlslResourceBinding* binding); /// To be documented. - [NativeName("Src", "Line 618, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 619, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_hlsl_resource_binding_init")] public partial void HlslResourceBindingInit(ref HlslResourceBinding binding); /// To be documented. - [NativeName("Src", "Line 761, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 768, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_create")] public unsafe partial Result ContextCreate(Context** context); /// To be documented. - [NativeName("Src", "Line 761, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 768, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_create")] public unsafe partial Result ContextCreate(ref Context* context); /// To be documented. - [NativeName("Src", "Line 764, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 771, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_destroy")] public unsafe partial void ContextDestroy(Context* context); /// To be documented. - [NativeName("Src", "Line 767, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 774, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_release_allocations")] public unsafe partial void ContextReleaseAllocations(Context* context); /// To be documented. - [NativeName("Src", "Line 770, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 777, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_get_last_error_string")] public unsafe partial byte* ContextGetLastErrorString(Context* context); /// To be documented. - [NativeName("Src", "Line 770, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 777, Column 29 in spirv_cross_c.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvc_context_get_last_error_string")] public unsafe partial string ContextGetLastErrorStringS(Context* context); /// To be documented. - [NativeName("Src", "Line 774, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 781, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_set_error_callback")] public unsafe partial void ContextSetErrorCallback(Context* context, PfnErrorCallback cb, void* userdata); /// To be documented. - [NativeName("Src", "Line 774, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 781, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_set_error_callback")] public unsafe partial void ContextSetErrorCallback(Context* context, PfnErrorCallback cb, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 777, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 784, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_parse_spirv")] public unsafe partial Result ContextParseSpirv(Context* context, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint* spirv, nuint word_count, ParsedIr** parsed_ir); /// To be documented. - [NativeName("Src", "Line 777, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 784, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_parse_spirv")] public unsafe partial Result ContextParseSpirv(Context* context, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint* spirv, nuint word_count, ref ParsedIr* parsed_ir); /// To be documented. - [NativeName("Src", "Line 777, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 784, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_parse_spirv")] public unsafe partial Result ContextParseSpirv(Context* context, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly uint spirv, nuint word_count, ParsedIr** parsed_ir); /// To be documented. - [NativeName("Src", "Line 777, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 784, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_parse_spirv")] public unsafe partial Result ContextParseSpirv(Context* context, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly uint spirv, nuint word_count, ref ParsedIr* parsed_ir); /// To be documented. - [NativeName("Src", "Line 784, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 791, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_create_compiler")] public unsafe partial Result ContextCreateCompiler(Context* context, Backend backend, ParsedIr* parsed_ir, CaptureMode mode, Compiler** compiler); /// To be documented. - [NativeName("Src", "Line 784, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 791, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_context_create_compiler")] public unsafe partial Result ContextCreateCompiler(Context* context, Backend backend, ParsedIr* parsed_ir, CaptureMode mode, ref Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 789, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 796, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_current_id_bound")] public unsafe partial uint CompilerGetCurrentIdBound(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 792, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 799, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_create_compiler_options")] public unsafe partial Result CompilerCreateCompilerOptions(Compiler* compiler, CompilerOptions** options); /// To be documented. - [NativeName("Src", "Line 792, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 799, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_create_compiler_options")] public unsafe partial Result CompilerCreateCompilerOptions(Compiler* compiler, ref CompilerOptions* options); /// To be documented. - [NativeName("Src", "Line 795, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 802, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_options_set_bool")] public unsafe partial Result CompilerOptionsSetBool(CompilerOptions* options, CompilerOption option, byte value); /// To be documented. - [NativeName("Src", "Line 797, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 804, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_options_set_uint")] public unsafe partial Result CompilerOptionsSetUint(CompilerOptions* options, CompilerOption option, uint value); /// To be documented. - [NativeName("Src", "Line 800, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 807, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_install_compiler_options")] public unsafe partial Result CompilerInstallCompilerOptions(Compiler* compiler, CompilerOptions* options); /// To be documented. - [NativeName("Src", "Line 804, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 811, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_compile")] public unsafe partial Result CompilerCompile(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** source); /// To be documented. - [NativeName("Src", "Line 804, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 811, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_compile")] public unsafe partial Result CompilerCompile(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* source); /// To be documented. - [NativeName("Src", "Line 807, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 814, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_add_header_line")] public unsafe partial Result CompilerAddHeaderLine(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* line); /// To be documented. - [NativeName("Src", "Line 807, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 814, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_add_header_line")] public unsafe partial Result CompilerAddHeaderLine(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte line); /// To be documented. - [NativeName("Src", "Line 807, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 814, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_add_header_line")] public unsafe partial Result CompilerAddHeaderLine(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string line); /// To be documented. - [NativeName("Src", "Line 808, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 815, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_require_extension")] public unsafe partial Result CompilerRequireExtension(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* ext); /// To be documented. - [NativeName("Src", "Line 808, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 815, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_require_extension")] public unsafe partial Result CompilerRequireExtension(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte ext); /// To be documented. - [NativeName("Src", "Line 808, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 815, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_require_extension")] public unsafe partial Result CompilerRequireExtension(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ext); /// To be documented. - [NativeName("Src", "Line 809, Column 24 in spirv_cross_c.h")] + [NativeName("Src", "Line 816, Column 24 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_num_required_extensions")] public unsafe partial nuint CompilerGetNumRequiredExtensions(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 810, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 817, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_required_extension")] public unsafe partial byte* CompilerGetRequiredExtension(Compiler* compiler, nuint index); /// To be documented. - [NativeName("Src", "Line 810, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 817, Column 29 in spirv_cross_c.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvc_compiler_get_required_extension")] public unsafe partial string CompilerGetRequiredExtensionS(Compiler* compiler, nuint index); /// To be documented. - [NativeName("Src", "Line 811, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 818, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_flatten_buffer_block")] public unsafe partial Result CompilerFlattenBufferBlock(Compiler* compiler, uint id); /// To be documented. - [NativeName("Src", "Line 813, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 820, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_variable_is_depth_or_compare")] public unsafe partial byte CompilerVariableIsDepthOrCompare(Compiler* compiler, uint id); /// To be documented. - [NativeName("Src", "Line 815, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 822, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_mask_stage_output_by_location")] public unsafe partial Result CompilerMaskStageOutputByLocation(Compiler* compiler, uint location, uint component); /// To be documented. - [NativeName("Src", "Line 817, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 824, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_mask_stage_output_by_builtin")] public unsafe partial Result CompilerMaskStageOutputByBuiltin(Compiler* compiler, Silk.NET.SPIRV.BuiltIn builtin); /// To be documented. - [NativeName("Src", "Line 823, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 830, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_hlsl_set_root_constants_layout")] public unsafe partial Result CompilerHlslSetRootConstantsLayout(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] HlslRootConstants* constant_info, nuint count); /// To be documented. - [NativeName("Src", "Line 823, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 830, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_hlsl_set_root_constants_layout")] public unsafe partial Result CompilerHlslSetRootConstantsLayout(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly HlslRootConstants constant_info, nuint count); /// To be documented. - [NativeName("Src", "Line 826, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 833, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_hlsl_add_vertex_attribute_remap")] public unsafe partial Result CompilerHlslAddVertexAttributeRemap(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] HlslVertexAttributeRemap* remap, nuint remaps); /// To be documented. - [NativeName("Src", "Line 826, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 833, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_hlsl_add_vertex_attribute_remap")] public unsafe partial Result CompilerHlslAddVertexAttributeRemap(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly HlslVertexAttributeRemap remap, nuint remaps); /// To be documented. - [NativeName("Src", "Line 829, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 836, Column 34 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_hlsl_remap_num_workgroups_builtin")] public unsafe partial uint CompilerHlslRemapNumWorkgroupsBuiltin(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 831, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 838, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_hlsl_set_resource_binding_flags")] public unsafe partial Result CompilerHlslSetResourceBindingFlags(Compiler* compiler, uint flags); /// To be documented. - [NativeName("Src", "Line 834, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 841, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_hlsl_add_resource_binding")] public unsafe partial Result CompilerHlslAddResourceBinding(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] HlslResourceBinding* binding); /// To be documented. - [NativeName("Src", "Line 834, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 841, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_hlsl_add_resource_binding")] public unsafe partial Result CompilerHlslAddResourceBinding(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly HlslResourceBinding binding); /// To be documented. - [NativeName("Src", "Line 836, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 843, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_hlsl_is_resource_used")] public unsafe partial byte CompilerHlslIsResourceUsed(Compiler* compiler, Silk.NET.SPIRV.ExecutionModel model, uint set, uint binding); /// To be documented. - [NativeName("Src", "Line 845, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 852, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_is_rasterization_disabled")] public unsafe partial byte CompilerMslIsRasterizationDisabled(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 848, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 855, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_needs_aux_buffer")] public unsafe partial byte CompilerMslNeedsAuxBuffer(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 849, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 856, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_needs_swizzle_buffer")] public unsafe partial byte CompilerMslNeedsSwizzleBuffer(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 850, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 857, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_needs_buffer_size_buffer")] public unsafe partial byte CompilerMslNeedsBufferSizeBuffer(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 852, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 859, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_needs_output_buffer")] public unsafe partial byte CompilerMslNeedsOutputBuffer(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 853, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 860, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_needs_patch_output_buffer")] public unsafe partial byte CompilerMslNeedsPatchOutputBuffer(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 854, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 861, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_needs_input_threadgroup_mem")] public unsafe partial byte CompilerMslNeedsInputThreadgroupMem(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 855, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 862, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_vertex_attribute")] public unsafe partial Result CompilerMslAddVertexAttribute(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslVertexAttribute* attrs); /// To be documented. - [NativeName("Src", "Line 855, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 862, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_vertex_attribute")] public unsafe partial Result CompilerMslAddVertexAttribute(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslVertexAttribute attrs); /// To be documented. - [NativeName("Src", "Line 858, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 865, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_resource_binding")] public unsafe partial Result CompilerMslAddResourceBinding(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslResourceBinding* binding); /// To be documented. - [NativeName("Src", "Line 858, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 865, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_resource_binding")] public unsafe partial Result CompilerMslAddResourceBinding(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslResourceBinding binding); /// To be documented. - [NativeName("Src", "Line 860, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 867, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_resource_binding_2")] public unsafe partial Result CompilerMslAddResourceBinding2(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslResourceBinding2* binding); /// To be documented. - [NativeName("Src", "Line 860, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 867, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_resource_binding_2")] public unsafe partial Result CompilerMslAddResourceBinding2(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslResourceBinding2 binding); /// To be documented. - [NativeName("Src", "Line 863, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 870, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_shader_input")] public unsafe partial Result CompilerMslAddShaderInput(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslShaderInterfaceVar* input); /// To be documented. - [NativeName("Src", "Line 863, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 870, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_shader_input")] public unsafe partial Result CompilerMslAddShaderInput(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslShaderInterfaceVar input); /// To be documented. - [NativeName("Src", "Line 865, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 872, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_shader_input_2")] public unsafe partial Result CompilerMslAddShaderInput2(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslShaderInterfaceVar2* input); /// To be documented. - [NativeName("Src", "Line 865, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 872, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_shader_input_2")] public unsafe partial Result CompilerMslAddShaderInput2(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslShaderInterfaceVar2 input); /// To be documented. - [NativeName("Src", "Line 868, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 875, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_shader_output")] public unsafe partial Result CompilerMslAddShaderOutput(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslShaderInterfaceVar* output); /// To be documented. - [NativeName("Src", "Line 868, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 875, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_shader_output")] public unsafe partial Result CompilerMslAddShaderOutput(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslShaderInterfaceVar output); /// To be documented. - [NativeName("Src", "Line 870, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 877, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_shader_output_2")] public unsafe partial Result CompilerMslAddShaderOutput2(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslShaderInterfaceVar2* output); /// To be documented. - [NativeName("Src", "Line 870, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 877, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_shader_output_2")] public unsafe partial Result CompilerMslAddShaderOutput2(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslShaderInterfaceVar2 output); /// To be documented. - [NativeName("Src", "Line 872, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 879, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_discrete_descriptor_set")] public unsafe partial Result CompilerMslAddDiscreteDescriptorSet(Compiler* compiler, uint desc_set); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 880, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_set_argument_buffer_device_address_space")] public unsafe partial Result CompilerMslSetArgumentBufferDeviceAddressSpace(Compiler* compiler, uint desc_set, byte device_address); /// To be documented. - [NativeName("Src", "Line 876, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 883, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_is_vertex_attribute_used")] public unsafe partial byte CompilerMslIsVertexAttributeUsed(Compiler* compiler, uint location); /// To be documented. - [NativeName("Src", "Line 877, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 884, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_is_shader_input_used")] public unsafe partial byte CompilerMslIsShaderInputUsed(Compiler* compiler, uint location); /// To be documented. - [NativeName("Src", "Line 878, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 885, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_is_shader_output_used")] public unsafe partial byte CompilerMslIsShaderOutputUsed(Compiler* compiler, uint location); /// To be documented. - [NativeName("Src", "Line 880, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 887, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_is_resource_used")] public unsafe partial byte CompilerMslIsResourceUsed(Compiler* compiler, Silk.NET.SPIRV.ExecutionModel model, uint set, uint binding); /// To be documented. - [NativeName("Src", "Line 884, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 891, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler")] public unsafe partial Result CompilerMslRemapConstexprSampler(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslConstexprSampler* sampler); /// To be documented. - [NativeName("Src", "Line 884, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 891, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler")] public unsafe partial Result CompilerMslRemapConstexprSampler(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslConstexprSampler sampler); /// To be documented. - [NativeName("Src", "Line 885, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 892, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler_by_binding")] public unsafe partial Result CompilerMslRemapConstexprSamplerByBinding(Compiler* compiler, uint desc_set, uint binding, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslConstexprSampler* sampler); /// To be documented. - [NativeName("Src", "Line 885, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 892, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler_by_binding")] public unsafe partial Result CompilerMslRemapConstexprSamplerByBinding(Compiler* compiler, uint desc_set, uint binding, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslConstexprSampler sampler); /// To be documented. - [NativeName("Src", "Line 886, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 893, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler_ycbcr")] public unsafe partial Result CompilerMslRemapConstexprSamplerYcbcr(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslConstexprSampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslSamplerYcbcrConversion* conv); /// To be documented. - [NativeName("Src", "Line 886, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 893, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler_ycbcr")] public unsafe partial Result CompilerMslRemapConstexprSamplerYcbcr(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslConstexprSampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslSamplerYcbcrConversion conv); /// To be documented. - [NativeName("Src", "Line 886, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 893, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler_ycbcr")] public unsafe partial Result CompilerMslRemapConstexprSamplerYcbcr(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslConstexprSampler sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslSamplerYcbcrConversion* conv); /// To be documented. - [NativeName("Src", "Line 886, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 893, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler_ycbcr")] public unsafe partial Result CompilerMslRemapConstexprSamplerYcbcr(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslConstexprSampler sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslSamplerYcbcrConversion conv); /// To be documented. - [NativeName("Src", "Line 887, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 894, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler_by_binding_ycbcr")] public unsafe partial Result CompilerMslRemapConstexprSamplerByBindingYcbcr(Compiler* compiler, uint desc_set, uint binding, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslConstexprSampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslSamplerYcbcrConversion* conv); /// To be documented. - [NativeName("Src", "Line 887, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 894, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler_by_binding_ycbcr")] public unsafe partial Result CompilerMslRemapConstexprSamplerByBindingYcbcr(Compiler* compiler, uint desc_set, uint binding, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslConstexprSampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslSamplerYcbcrConversion conv); /// To be documented. - [NativeName("Src", "Line 887, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 894, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler_by_binding_ycbcr")] public unsafe partial Result CompilerMslRemapConstexprSamplerByBindingYcbcr(Compiler* compiler, uint desc_set, uint binding, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslConstexprSampler sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslSamplerYcbcrConversion* conv); /// To be documented. - [NativeName("Src", "Line 887, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 894, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_remap_constexpr_sampler_by_binding_ycbcr")] public unsafe partial Result CompilerMslRemapConstexprSamplerByBindingYcbcr(Compiler* compiler, uint desc_set, uint binding, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslConstexprSampler sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MslSamplerYcbcrConversion conv); /// To be documented. - [NativeName("Src", "Line 888, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 895, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_set_fragment_output_components")] public unsafe partial Result CompilerMslSetFragmentOutputComponents(Compiler* compiler, uint location, uint components); /// To be documented. - [NativeName("Src", "Line 890, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 897, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_get_automatic_resource_binding")] public unsafe partial uint CompilerMslGetAutomaticResourceBinding(Compiler* compiler, uint id); /// To be documented. - [NativeName("Src", "Line 891, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 898, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_get_automatic_resource_binding_secondary")] public unsafe partial uint CompilerMslGetAutomaticResourceBindingSecondary(Compiler* compiler, uint id); /// To be documented. - [NativeName("Src", "Line 893, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 900, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_dynamic_buffer")] public unsafe partial Result CompilerMslAddDynamicBuffer(Compiler* compiler, uint desc_set, uint binding, uint index); /// To be documented. - [NativeName("Src", "Line 895, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 902, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_add_inline_uniform_block")] public unsafe partial Result CompilerMslAddInlineUniformBlock(Compiler* compiler, uint desc_set, uint binding); /// To be documented. - [NativeName("Src", "Line 897, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 904, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_set_combined_sampler_suffix")] public unsafe partial Result CompilerMslSetCombinedSamplerSuffix(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* suffix); /// To be documented. - [NativeName("Src", "Line 897, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 904, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_set_combined_sampler_suffix")] public unsafe partial Result CompilerMslSetCombinedSamplerSuffix(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte suffix); /// To be documented. - [NativeName("Src", "Line 897, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 904, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_set_combined_sampler_suffix")] public unsafe partial Result CompilerMslSetCombinedSamplerSuffix(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string suffix); /// To be documented. - [NativeName("Src", "Line 898, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 905, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_msl_get_combined_sampler_suffix")] public unsafe partial byte* CompilerMslGetCombinedSamplerSuffix(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 898, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 905, Column 29 in spirv_cross_c.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvc_compiler_msl_get_combined_sampler_suffix")] public unsafe partial string CompilerMslGetCombinedSamplerSuffixS(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 904, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 911, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_active_interface_variables")] public unsafe partial Result CompilerGetActiveInterfaceVariables(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Set** set); /// To be documented. - [NativeName("Src", "Line 904, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 911, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_active_interface_variables")] public unsafe partial Result CompilerGetActiveInterfaceVariables(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Set* set); /// To be documented. - [NativeName("Src", "Line 905, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 912, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_enabled_interface_variables")] public unsafe partial Result CompilerSetEnabledInterfaceVariables(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Set* set); /// To be documented. - [NativeName("Src", "Line 906, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 913, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_create_shader_resources")] public unsafe partial Result CompilerCreateShaderResources(Compiler* compiler, Resources** resources); /// To be documented. - [NativeName("Src", "Line 906, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 913, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_create_shader_resources")] public unsafe partial Result CompilerCreateShaderResources(Compiler* compiler, ref Resources* resources); /// To be documented. - [NativeName("Src", "Line 907, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 914, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_create_shader_resources_for_active_variables")] public unsafe partial Result CompilerCreateShaderResourcesForActiveVariables(Compiler* compiler, Resources** resources, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Set* active); /// To be documented. - [NativeName("Src", "Line 907, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 914, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_create_shader_resources_for_active_variables")] public unsafe partial Result CompilerCreateShaderResourcesForActiveVariables(Compiler* compiler, ref Resources* resources, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Set* active); /// To be documented. - [NativeName("Src", "Line 910, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 917, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_resources_get_resource_list_for_type")] public unsafe partial Result ResourcesGetResourceListForType(Resources* resources, ResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectedResource** resource_list, nuint* resource_size); /// To be documented. - [NativeName("Src", "Line 910, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 917, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_resources_get_resource_list_for_type")] public unsafe partial Result ResourcesGetResourceListForType(Resources* resources, ResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectedResource** resource_list, ref nuint resource_size); /// To be documented. - [NativeName("Src", "Line 910, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 917, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_resources_get_resource_list_for_type")] public unsafe partial Result ResourcesGetResourceListForType(Resources* resources, ResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectedResource* resource_list, nuint* resource_size); /// To be documented. - [NativeName("Src", "Line 910, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 917, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_resources_get_resource_list_for_type")] public unsafe partial Result ResourcesGetResourceListForType(Resources* resources, ResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectedResource* resource_list, ref nuint resource_size); /// To be documented. - [NativeName("Src", "Line 914, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 921, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_resources_get_builtin_resource_list_for_type")] public unsafe partial Result ResourcesGetBuiltinResourceListForType(Resources* resources, BuiltinResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectedBuiltinResource** resource_list, nuint* resource_size); /// To be documented. - [NativeName("Src", "Line 914, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 921, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_resources_get_builtin_resource_list_for_type")] public unsafe partial Result ResourcesGetBuiltinResourceListForType(Resources* resources, BuiltinResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectedBuiltinResource** resource_list, ref nuint resource_size); /// To be documented. - [NativeName("Src", "Line 914, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 921, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_resources_get_builtin_resource_list_for_type")] public unsafe partial Result ResourcesGetBuiltinResourceListForType(Resources* resources, BuiltinResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectedBuiltinResource* resource_list, nuint* resource_size); /// To be documented. - [NativeName("Src", "Line 914, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 921, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_resources_get_builtin_resource_list_for_type")] public unsafe partial Result ResourcesGetBuiltinResourceListForType(Resources* resources, BuiltinResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectedBuiltinResource* resource_list, ref nuint resource_size); /// To be documented. - [NativeName("Src", "Line 923, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 930, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_decoration")] public unsafe partial void CompilerSetDecoration(Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration, uint argument); /// To be documented. - [NativeName("Src", "Line 925, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 932, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_decoration_string")] public unsafe partial void CompilerSetDecorationString(Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* argument); /// To be documented. - [NativeName("Src", "Line 925, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 932, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_decoration_string")] public unsafe partial void CompilerSetDecorationString(Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte argument); /// To be documented. - [NativeName("Src", "Line 925, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 932, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_decoration_string")] public unsafe partial void CompilerSetDecorationString(Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string argument); /// To be documented. - [NativeName("Src", "Line 927, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 934, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_name")] public unsafe partial void CompilerSetName(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* argument); /// To be documented. - [NativeName("Src", "Line 927, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 934, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_name")] public unsafe partial void CompilerSetName(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte argument); /// To be documented. - [NativeName("Src", "Line 927, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 934, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_name")] public unsafe partial void CompilerSetName(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string argument); /// To be documented. - [NativeName("Src", "Line 928, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 935, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_member_decoration")] public unsafe partial void CompilerSetMemberDecoration(Compiler* compiler, uint id, uint member_index, Silk.NET.SPIRV.Decoration decoration, uint argument); /// To be documented. - [NativeName("Src", "Line 930, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 937, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_member_decoration_string")] public unsafe partial void CompilerSetMemberDecorationString(Compiler* compiler, uint id, uint member_index, Silk.NET.SPIRV.Decoration decoration, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* argument); /// To be documented. - [NativeName("Src", "Line 930, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 937, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_member_decoration_string")] public unsafe partial void CompilerSetMemberDecorationString(Compiler* compiler, uint id, uint member_index, Silk.NET.SPIRV.Decoration decoration, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte argument); /// To be documented. - [NativeName("Src", "Line 930, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 937, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_member_decoration_string")] public unsafe partial void CompilerSetMemberDecorationString(Compiler* compiler, uint id, uint member_index, Silk.NET.SPIRV.Decoration decoration, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string argument); /// To be documented. - [NativeName("Src", "Line 933, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 940, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_member_name")] public unsafe partial void CompilerSetMemberName(Compiler* compiler, uint id, uint member_index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* argument); /// To be documented. - [NativeName("Src", "Line 933, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 940, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_member_name")] public unsafe partial void CompilerSetMemberName(Compiler* compiler, uint id, uint member_index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte argument); /// To be documented. - [NativeName("Src", "Line 933, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 940, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_member_name")] public unsafe partial void CompilerSetMemberName(Compiler* compiler, uint id, uint member_index, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string argument); /// To be documented. - [NativeName("Src", "Line 935, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 942, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_unset_decoration")] public unsafe partial void CompilerUnsetDecoration(Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration); /// To be documented. - [NativeName("Src", "Line 936, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 943, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_unset_member_decoration")] public unsafe partial void CompilerUnsetMemberDecoration(Compiler* compiler, uint id, uint member_index, Silk.NET.SPIRV.Decoration decoration); /// To be documented. - [NativeName("Src", "Line 939, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 946, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_has_decoration")] public unsafe partial byte CompilerHasDecoration(Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration); /// To be documented. - [NativeName("Src", "Line 940, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 947, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_has_member_decoration")] public unsafe partial byte CompilerHasMemberDecoration(Compiler* compiler, uint id, uint member_index, Silk.NET.SPIRV.Decoration decoration); /// To be documented. - [NativeName("Src", "Line 942, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 949, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_name")] public unsafe partial byte* CompilerGetName(Compiler* compiler, uint id); /// To be documented. - [NativeName("Src", "Line 942, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 949, Column 29 in spirv_cross_c.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvc_compiler_get_name")] public unsafe partial string CompilerGetNameS(Compiler* compiler, uint id); /// To be documented. - [NativeName("Src", "Line 943, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 950, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_decoration")] public unsafe partial uint CompilerGetDecoration(Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration); /// To be documented. - [NativeName("Src", "Line 944, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 951, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_decoration_string")] public unsafe partial byte* CompilerGetDecorationString(Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration); /// To be documented. - [NativeName("Src", "Line 944, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 951, Column 29 in spirv_cross_c.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvc_compiler_get_decoration_string")] public unsafe partial string CompilerGetDecorationStringS(Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration); /// To be documented. - [NativeName("Src", "Line 946, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 953, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_member_decoration")] public unsafe partial uint CompilerGetMemberDecoration(Compiler* compiler, uint id, uint member_index, Silk.NET.SPIRV.Decoration decoration); /// To be documented. - [NativeName("Src", "Line 948, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 955, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_member_decoration_string")] public unsafe partial byte* CompilerGetMemberDecorationString(Compiler* compiler, uint id, uint member_index, Silk.NET.SPIRV.Decoration decoration); /// To be documented. - [NativeName("Src", "Line 948, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 955, Column 29 in spirv_cross_c.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvc_compiler_get_member_decoration_string")] public unsafe partial string CompilerGetMemberDecorationStringS(Compiler* compiler, uint id, uint member_index, Silk.NET.SPIRV.Decoration decoration); /// To be documented. - [NativeName("Src", "Line 950, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 957, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_member_name")] public unsafe partial byte* CompilerGetMemberName(Compiler* compiler, uint id, uint member_index); /// To be documented. - [NativeName("Src", "Line 950, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 957, Column 29 in spirv_cross_c.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvc_compiler_get_member_name")] public unsafe partial string CompilerGetMemberNameS(Compiler* compiler, uint id, uint member_index); /// To be documented. - [NativeName("Src", "Line 956, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_entry_points")] public unsafe partial Result CompilerGetEntryPoints(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EntryPoint** entry_points, nuint* num_entry_points); /// To be documented. - [NativeName("Src", "Line 956, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_entry_points")] public unsafe partial Result CompilerGetEntryPoints(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EntryPoint** entry_points, ref nuint num_entry_points); /// To be documented. - [NativeName("Src", "Line 956, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_entry_points")] public unsafe partial Result CompilerGetEntryPoints(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly EntryPoint* entry_points, nuint* num_entry_points); /// To be documented. - [NativeName("Src", "Line 956, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_entry_points")] public unsafe partial Result CompilerGetEntryPoints(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly EntryPoint* entry_points, ref nuint num_entry_points); /// To be documented. - [NativeName("Src", "Line 959, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 966, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_entry_point")] public unsafe partial Result CompilerSetEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 959, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 966, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_entry_point")] public unsafe partial Result CompilerSetEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 959, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 966, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_entry_point")] public unsafe partial Result CompilerSetEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_rename_entry_point")] public unsafe partial Result CompilerRenameEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* new_name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_rename_entry_point")] public unsafe partial Result CompilerRenameEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte new_name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_rename_entry_point")] public unsafe partial Result CompilerRenameEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string new_name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_rename_entry_point")] public unsafe partial Result CompilerRenameEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* new_name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_rename_entry_point")] public unsafe partial Result CompilerRenameEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte new_name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_rename_entry_point")] public unsafe partial Result CompilerRenameEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string new_name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_rename_entry_point")] public unsafe partial Result CompilerRenameEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* new_name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_rename_entry_point")] public unsafe partial Result CompilerRenameEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte new_name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_rename_entry_point")] public unsafe partial Result CompilerRenameEntryPoint(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string new_name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 970, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_cleansed_entry_point_name")] public unsafe partial byte* CompilerGetCleansedEntryPointName(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 970, Column 29 in spirv_cross_c.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvc_compiler_get_cleansed_entry_point_name")] public unsafe partial string CompilerGetCleansedEntryPointNameS(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 970, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_cleansed_entry_point_name")] public unsafe partial byte* CompilerGetCleansedEntryPointName(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 970, Column 29 in spirv_cross_c.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvc_compiler_get_cleansed_entry_point_name")] public unsafe partial string CompilerGetCleansedEntryPointNameS(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 970, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_cleansed_entry_point_name")] public unsafe partial byte* CompilerGetCleansedEntryPointName(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 970, Column 29 in spirv_cross_c.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvc_compiler_get_cleansed_entry_point_name")] public unsafe partial string CompilerGetCleansedEntryPointNameS(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, Silk.NET.SPIRV.ExecutionModel model); /// To be documented. - [NativeName("Src", "Line 965, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 972, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_execution_mode")] public unsafe partial void CompilerSetExecutionMode(Compiler* compiler, Silk.NET.SPIRV.ExecutionMode mode); /// To be documented. - [NativeName("Src", "Line 966, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 973, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_unset_execution_mode")] public unsafe partial void CompilerUnsetExecutionMode(Compiler* compiler, Silk.NET.SPIRV.ExecutionMode mode); /// To be documented. - [NativeName("Src", "Line 967, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 974, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_set_execution_mode_with_arguments")] public unsafe partial void CompilerSetExecutionModeWithArguments(Compiler* compiler, Silk.NET.SPIRV.ExecutionMode mode, uint arg0, uint arg1, uint arg2); /// To be documented. - [NativeName("Src", "Line 969, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 976, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_execution_modes")] public unsafe partial Result CompilerGetExecutionModes(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.SPIRV.ExecutionMode** modes, nuint* num_modes); /// To be documented. - [NativeName("Src", "Line 969, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 976, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_execution_modes")] public unsafe partial Result CompilerGetExecutionModes(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.SPIRV.ExecutionMode** modes, ref nuint num_modes); /// To be documented. - [NativeName("Src", "Line 969, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 976, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_execution_modes")] public unsafe partial Result CompilerGetExecutionModes(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.SPIRV.ExecutionMode* modes, nuint* num_modes); /// To be documented. - [NativeName("Src", "Line 969, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 976, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_execution_modes")] public unsafe partial Result CompilerGetExecutionModes(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.SPIRV.ExecutionMode* modes, ref nuint num_modes); /// To be documented. - [NativeName("Src", "Line 971, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 978, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_execution_mode_argument")] public unsafe partial uint CompilerGetExecutionModeArgument(Compiler* compiler, Silk.NET.SPIRV.ExecutionMode mode); /// To be documented. - [NativeName("Src", "Line 972, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 979, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_execution_mode_argument_by_index")] public unsafe partial uint CompilerGetExecutionModeArgumentByIndex(Compiler* compiler, Silk.NET.SPIRV.ExecutionMode mode, uint index); /// To be documented. - [NativeName("Src", "Line 974, Column 35 in spirv_cross_c.h")] + [NativeName("Src", "Line 981, Column 35 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_execution_model")] public unsafe partial Silk.NET.SPIRV.ExecutionModel CompilerGetExecutionModel(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 975, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 982, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_update_active_builtins")] public unsafe partial void CompilerUpdateActiveBuiltins(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 976, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 983, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_has_active_builtin")] public unsafe partial byte CompilerHasActiveBuiltin(Compiler* compiler, Silk.NET.SPIRV.BuiltIn builtin, Silk.NET.SPIRV.StorageClass storage); /// To be documented. - [NativeName("Src", "Line 982, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 989, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_type_handle")] public unsafe partial CrossType* CompilerGetTypeHandle(Compiler* compiler, uint id); /// To be documented. - [NativeName("Src", "Line 988, Column 30 in spirv_cross_c.h")] + [NativeName("Src", "Line 995, Column 30 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_base_type_id")] public unsafe partial uint TypeGetBaseTypeId([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 990, Column 31 in spirv_cross_c.h")] + [NativeName("Src", "Line 997, Column 31 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_basetype")] public unsafe partial Basetype TypeGetBasetype([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 991, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 998, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_bit_width")] public unsafe partial uint TypeGetBitWidth([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 992, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 999, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_vector_size")] public unsafe partial uint TypeGetVectorSize([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 993, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 1000, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_columns")] public unsafe partial uint TypeGetColumns([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 994, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 1001, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_num_array_dimensions")] public unsafe partial uint TypeGetNumArrayDimensions([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 995, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1002, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_array_dimension_is_literal")] public unsafe partial byte TypeArrayDimensionIsLiteral([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint dimension); /// To be documented. - [NativeName("Src", "Line 996, Column 23 in spirv_cross_c.h")] + [NativeName("Src", "Line 1003, Column 23 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_array_dimension")] public unsafe partial uint TypeGetArrayDimension([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint dimension); /// To be documented. - [NativeName("Src", "Line 997, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 1004, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_num_member_types")] public unsafe partial uint TypeGetNumMemberTypes([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 998, Column 30 in spirv_cross_c.h")] + [NativeName("Src", "Line 1005, Column 30 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_member_type")] public unsafe partial uint TypeGetMemberType([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index); /// To be documented. - [NativeName("Src", "Line 999, Column 33 in spirv_cross_c.h")] + [NativeName("Src", "Line 1006, Column 33 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_storage_class")] public unsafe partial Silk.NET.SPIRV.StorageClass TypeGetStorageClass([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 1002, Column 30 in spirv_cross_c.h")] + [NativeName("Src", "Line 1009, Column 30 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_image_sampled_type")] public unsafe partial uint TypeGetImageSampledType([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 1003, Column 24 in spirv_cross_c.h")] + [NativeName("Src", "Line 1010, Column 24 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_image_dimension")] public unsafe partial Silk.NET.SPIRV.Dim TypeGetImageDimension([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 1004, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1011, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_image_is_depth")] public unsafe partial byte TypeGetImageIsDepth([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 1005, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1012, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_image_arrayed")] public unsafe partial byte TypeGetImageArrayed([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 1006, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1013, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_image_multisampled")] public unsafe partial byte TypeGetImageMultisampled([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 1007, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1014, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_image_is_storage")] public unsafe partial byte TypeGetImageIsStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 1008, Column 32 in spirv_cross_c.h")] + [NativeName("Src", "Line 1015, Column 32 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_image_storage_format")] public unsafe partial Silk.NET.SPIRV.ImageFormat TypeGetImageStorageFormat([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 1009, Column 36 in spirv_cross_c.h")] + [NativeName("Src", "Line 1016, Column 36 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_type_get_image_access_qualifier")] public unsafe partial Silk.NET.SPIRV.AccessQualifier TypeGetImageAccessQualifier([Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type); /// To be documented. - [NativeName("Src", "Line 1015, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1022, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_struct_size")] public unsafe partial Result CompilerGetDeclaredStructSize(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* struct_type, nuint* size); /// To be documented. - [NativeName("Src", "Line 1015, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1022, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_struct_size")] public unsafe partial Result CompilerGetDeclaredStructSize(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* struct_type, ref nuint size); /// To be documented. - [NativeName("Src", "Line 1016, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1023, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_struct_size_runtime_array")] public unsafe partial Result CompilerGetDeclaredStructSizeRuntimeArray(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* struct_type, nuint array_size, nuint* size); /// To be documented. - [NativeName("Src", "Line 1016, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1023, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_struct_size_runtime_array")] public unsafe partial Result CompilerGetDeclaredStructSizeRuntimeArray(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* struct_type, nuint array_size, ref nuint size); /// To be documented. - [NativeName("Src", "Line 1018, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1025, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_struct_member_size")] public unsafe partial Result CompilerGetDeclaredStructMemberSize(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, nuint* size); /// To be documented. - [NativeName("Src", "Line 1018, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1025, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_struct_member_size")] public unsafe partial Result CompilerGetDeclaredStructMemberSize(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, ref nuint size); /// To be documented. - [NativeName("Src", "Line 1020, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1027, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_type_struct_member_offset")] public unsafe partial Result CompilerTypeStructMemberOffset(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, uint* offset); /// To be documented. - [NativeName("Src", "Line 1020, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1027, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_type_struct_member_offset")] public unsafe partial Result CompilerTypeStructMemberOffset(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, ref uint offset); /// To be documented. - [NativeName("Src", "Line 1022, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1029, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_type_struct_member_array_stride")] public unsafe partial Result CompilerTypeStructMemberArrayStride(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, uint* stride); /// To be documented. - [NativeName("Src", "Line 1022, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1029, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_type_struct_member_array_stride")] public unsafe partial Result CompilerTypeStructMemberArrayStride(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, ref uint stride); /// To be documented. - [NativeName("Src", "Line 1024, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1031, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_type_struct_member_matrix_stride")] public unsafe partial Result CompilerTypeStructMemberMatrixStride(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, uint* stride); /// To be documented. - [NativeName("Src", "Line 1024, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1031, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_type_struct_member_matrix_stride")] public unsafe partial Result CompilerTypeStructMemberMatrixStride(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, ref uint stride); /// To be documented. - [NativeName("Src", "Line 1031, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1038, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_build_dummy_sampler_for_combined_images")] public unsafe partial Result CompilerBuildDummySamplerForCombinedImages(Compiler* compiler, uint* id); /// To be documented. - [NativeName("Src", "Line 1031, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1038, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_build_dummy_sampler_for_combined_images")] public unsafe partial Result CompilerBuildDummySamplerForCombinedImages(Compiler* compiler, ref uint id); /// To be documented. - [NativeName("Src", "Line 1032, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1039, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_build_combined_image_samplers")] public unsafe partial Result CompilerBuildCombinedImageSamplers(Compiler* compiler); /// To be documented. - [NativeName("Src", "Line 1033, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1040, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_combined_image_samplers")] public unsafe partial Result CompilerGetCombinedImageSamplers(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CombinedImageSampler** samplers, nuint* num_samplers); /// To be documented. - [NativeName("Src", "Line 1033, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1040, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_combined_image_samplers")] public unsafe partial Result CompilerGetCombinedImageSamplers(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CombinedImageSampler** samplers, ref nuint num_samplers); /// To be documented. - [NativeName("Src", "Line 1033, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1040, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_combined_image_samplers")] public unsafe partial Result CompilerGetCombinedImageSamplers(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly CombinedImageSampler* samplers, nuint* num_samplers); /// To be documented. - [NativeName("Src", "Line 1033, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1040, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_combined_image_samplers")] public unsafe partial Result CompilerGetCombinedImageSamplers(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly CombinedImageSampler* samplers, ref nuint num_samplers); /// To be documented. - [NativeName("Src", "Line 1041, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1048, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_specialization_constants")] public unsafe partial Result CompilerGetSpecializationConstants(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SpecializationConstant** constants, nuint* num_constants); /// To be documented. - [NativeName("Src", "Line 1041, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1048, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_specialization_constants")] public unsafe partial Result CompilerGetSpecializationConstants(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SpecializationConstant** constants, ref nuint num_constants); /// To be documented. - [NativeName("Src", "Line 1041, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1048, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_specialization_constants")] public unsafe partial Result CompilerGetSpecializationConstants(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly SpecializationConstant* constants, nuint* num_constants); /// To be documented. - [NativeName("Src", "Line 1041, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1048, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_specialization_constants")] public unsafe partial Result CompilerGetSpecializationConstants(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly SpecializationConstant* constants, ref nuint num_constants); /// To be documented. - [NativeName("Src", "Line 1044, Column 31 in spirv_cross_c.h")] + [NativeName("Src", "Line 1051, Column 31 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_constant_handle")] public unsafe partial Constant* CompilerGetConstantHandle(Compiler* compiler, uint id); /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_work_group_size_specialization_constants")] public unsafe partial uint CompilerGetWorkGroupSizeSpecializationConstants(Compiler* compiler, SpecializationConstant* x, SpecializationConstant* y, SpecializationConstant* z); /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_work_group_size_specialization_constants")] public unsafe partial uint CompilerGetWorkGroupSizeSpecializationConstants(Compiler* compiler, SpecializationConstant* x, SpecializationConstant* y, ref SpecializationConstant z); /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_work_group_size_specialization_constants")] public unsafe partial uint CompilerGetWorkGroupSizeSpecializationConstants(Compiler* compiler, SpecializationConstant* x, ref SpecializationConstant y, SpecializationConstant* z); /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_work_group_size_specialization_constants")] public unsafe partial uint CompilerGetWorkGroupSizeSpecializationConstants(Compiler* compiler, SpecializationConstant* x, ref SpecializationConstant y, ref SpecializationConstant z); /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_work_group_size_specialization_constants")] public unsafe partial uint CompilerGetWorkGroupSizeSpecializationConstants(Compiler* compiler, ref SpecializationConstant x, SpecializationConstant* y, SpecializationConstant* z); /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_work_group_size_specialization_constants")] public unsafe partial uint CompilerGetWorkGroupSizeSpecializationConstants(Compiler* compiler, ref SpecializationConstant x, SpecializationConstant* y, ref SpecializationConstant z); /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_work_group_size_specialization_constants")] public unsafe partial uint CompilerGetWorkGroupSizeSpecializationConstants(Compiler* compiler, ref SpecializationConstant x, ref SpecializationConstant y, SpecializationConstant* z); /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_work_group_size_specialization_constants")] public unsafe partial uint CompilerGetWorkGroupSizeSpecializationConstants(Compiler* compiler, ref SpecializationConstant x, ref SpecializationConstant y, ref SpecializationConstant z); /// To be documented. - [NativeName("Src", "Line 1056, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1063, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_active_buffer_ranges")] public unsafe partial Result CompilerGetActiveBufferRanges(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BufferRange** ranges, nuint* num_ranges); /// To be documented. - [NativeName("Src", "Line 1056, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1063, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_active_buffer_ranges")] public unsafe partial Result CompilerGetActiveBufferRanges(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BufferRange** ranges, ref nuint num_ranges); /// To be documented. - [NativeName("Src", "Line 1056, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1063, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_active_buffer_ranges")] public unsafe partial Result CompilerGetActiveBufferRanges(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly BufferRange* ranges, nuint* num_ranges); /// To be documented. - [NativeName("Src", "Line 1056, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1063, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_active_buffer_ranges")] public unsafe partial Result CompilerGetActiveBufferRanges(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly BufferRange* ranges, ref nuint num_ranges); /// To be documented. - [NativeName("Src", "Line 1067, Column 23 in spirv_cross_c.h")] + [NativeName("Src", "Line 1074, Column 23 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_scalar_fp16")] public unsafe partial float ConstantGetScalarFp16(Constant* constant, uint column, uint row); /// To be documented. - [NativeName("Src", "Line 1068, Column 23 in spirv_cross_c.h")] + [NativeName("Src", "Line 1075, Column 23 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_scalar_fp32")] public unsafe partial float ConstantGetScalarFp32(Constant* constant, uint column, uint row); /// To be documented. - [NativeName("Src", "Line 1069, Column 24 in spirv_cross_c.h")] + [NativeName("Src", "Line 1076, Column 24 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_scalar_fp64")] public unsafe partial double ConstantGetScalarFp64(Constant* constant, uint column, uint row); /// To be documented. - [NativeName("Src", "Line 1070, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 1077, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_scalar_u32")] public unsafe partial uint ConstantGetScalarU32(Constant* constant, uint column, uint row); /// To be documented. - [NativeName("Src", "Line 1071, Column 21 in spirv_cross_c.h")] + [NativeName("Src", "Line 1078, Column 21 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_scalar_i32")] public unsafe partial int ConstantGetScalarI32(Constant* constant, uint column, uint row); /// To be documented. - [NativeName("Src", "Line 1072, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 1079, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_scalar_u16")] public unsafe partial uint ConstantGetScalarU16(Constant* constant, uint column, uint row); /// To be documented. - [NativeName("Src", "Line 1073, Column 21 in spirv_cross_c.h")] + [NativeName("Src", "Line 1080, Column 21 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_scalar_i16")] public unsafe partial int ConstantGetScalarI16(Constant* constant, uint column, uint row); /// To be documented. - [NativeName("Src", "Line 1074, Column 26 in spirv_cross_c.h")] + [NativeName("Src", "Line 1081, Column 26 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_scalar_u8")] public unsafe partial uint ConstantGetScalarU8(Constant* constant, uint column, uint row); /// To be documented. - [NativeName("Src", "Line 1075, Column 21 in spirv_cross_c.h")] + [NativeName("Src", "Line 1082, Column 21 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_scalar_i8")] public unsafe partial int ConstantGetScalarI8(Constant* constant, uint column, uint row); /// To be documented. - [NativeName("Src", "Line 1076, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1083, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_subconstants")] public unsafe partial void ConstantGetSubconstants(Constant* constant, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint** constituents, nuint* count); /// To be documented. - [NativeName("Src", "Line 1076, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1083, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_subconstants")] public unsafe partial void ConstantGetSubconstants(Constant* constant, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint** constituents, ref nuint count); /// To be documented. - [NativeName("Src", "Line 1076, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1083, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_subconstants")] public unsafe partial void ConstantGetSubconstants(Constant* constant, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly uint* constituents, nuint* count); /// To be documented. - [NativeName("Src", "Line 1076, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1083, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_subconstants")] public unsafe partial void ConstantGetSubconstants(Constant* constant, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly uint* constituents, ref nuint count); /// To be documented. - [NativeName("Src", "Line 1077, Column 36 in spirv_cross_c.h")] + [NativeName("Src", "Line 1084, Column 36 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_scalar_u64")] public unsafe partial ulong ConstantGetScalarU64(Constant* constant, uint column, uint row); /// To be documented. - [NativeName("Src", "Line 1078, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1085, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_scalar_i64")] public unsafe partial long ConstantGetScalarI64(Constant* constant, uint column, uint row); /// To be documented. - [NativeName("Src", "Line 1079, Column 30 in spirv_cross_c.h")] + [NativeName("Src", "Line 1086, Column 30 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_get_type")] public unsafe partial uint ConstantGetType(Constant* constant); /// To be documented. - [NativeName("Src", "Line 1084, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1091, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_set_scalar_fp16")] public unsafe partial void ConstantSetScalarFp16(Constant* constant, uint column, uint row, ushort value); /// To be documented. - [NativeName("Src", "Line 1085, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1092, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_set_scalar_fp32")] public unsafe partial void ConstantSetScalarFp32(Constant* constant, uint column, uint row, float value); /// To be documented. - [NativeName("Src", "Line 1086, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1093, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_set_scalar_fp64")] public unsafe partial void ConstantSetScalarFp64(Constant* constant, uint column, uint row, double value); /// To be documented. - [NativeName("Src", "Line 1087, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1094, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_set_scalar_u32")] public unsafe partial void ConstantSetScalarU32(Constant* constant, uint column, uint row, uint value); /// To be documented. - [NativeName("Src", "Line 1088, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1095, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_set_scalar_i32")] public unsafe partial void ConstantSetScalarI32(Constant* constant, uint column, uint row, int value); /// To be documented. - [NativeName("Src", "Line 1089, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1096, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_set_scalar_u64")] public unsafe partial void ConstantSetScalarU64(Constant* constant, uint column, uint row, ulong value); /// To be documented. - [NativeName("Src", "Line 1090, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1097, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_set_scalar_i64")] public unsafe partial void ConstantSetScalarI64(Constant* constant, uint column, uint row, long value); /// To be documented. - [NativeName("Src", "Line 1091, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1098, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_set_scalar_u16")] public unsafe partial void ConstantSetScalarU16(Constant* constant, uint column, uint row, ushort value); /// To be documented. - [NativeName("Src", "Line 1092, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1099, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_set_scalar_i16")] public unsafe partial void ConstantSetScalarI16(Constant* constant, uint column, uint row, short value); /// To be documented. - [NativeName("Src", "Line 1093, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1100, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_set_scalar_u8")] public unsafe partial void ConstantSetScalarU8(Constant* constant, uint column, uint row, byte value); /// To be documented. - [NativeName("Src", "Line 1094, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1101, Column 22 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_constant_set_scalar_i8")] public unsafe partial void ConstantSetScalarI8(Constant* constant, uint column, uint row, byte value); /// To be documented. - [NativeName("Src", "Line 1100, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1107, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_binary_offset_for_decoration")] public unsafe partial byte CompilerGetBinaryOffsetForDecoration(Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration, uint* word_offset); /// To be documented. - [NativeName("Src", "Line 1100, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1107, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_binary_offset_for_decoration")] public unsafe partial byte CompilerGetBinaryOffsetForDecoration(Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration, ref uint word_offset); /// To be documented. - [NativeName("Src", "Line 1105, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1112, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_buffer_is_hlsl_counter_buffer")] public unsafe partial byte CompilerBufferIsHlslCounterBuffer(Compiler* compiler, uint id); /// To be documented. - [NativeName("Src", "Line 1106, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1113, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_buffer_get_hlsl_counter_buffer")] public unsafe partial byte CompilerBufferGetHlslCounterBuffer(Compiler* compiler, uint id, uint* counter_id); /// To be documented. - [NativeName("Src", "Line 1106, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1113, Column 27 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_buffer_get_hlsl_counter_buffer")] public unsafe partial byte CompilerBufferGetHlslCounterBuffer(Compiler* compiler, uint id, ref uint counter_id); /// To be documented. - [NativeName("Src", "Line 1109, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_capabilities")] public unsafe partial Result CompilerGetDeclaredCapabilities(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.SPIRV.Capability** capabilities, nuint* num_capabilities); /// To be documented. - [NativeName("Src", "Line 1109, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_capabilities")] public unsafe partial Result CompilerGetDeclaredCapabilities(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.SPIRV.Capability** capabilities, ref nuint num_capabilities); /// To be documented. - [NativeName("Src", "Line 1109, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_capabilities")] public unsafe partial Result CompilerGetDeclaredCapabilities(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.SPIRV.Capability* capabilities, nuint* num_capabilities); /// To be documented. - [NativeName("Src", "Line 1109, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_capabilities")] public unsafe partial Result CompilerGetDeclaredCapabilities(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.SPIRV.Capability* capabilities, ref nuint num_capabilities); /// To be documented. - [NativeName("Src", "Line 1112, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1119, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_extensions")] public unsafe partial Result CompilerGetDeclaredExtensions(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte*** extensions, nuint* num_extensions); /// To be documented. - [NativeName("Src", "Line 1112, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1119, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_extensions")] public unsafe partial Result CompilerGetDeclaredExtensions(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte*** extensions, ref nuint num_extensions); /// To be documented. - [NativeName("Src", "Line 1112, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1119, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_extensions")] public unsafe partial Result CompilerGetDeclaredExtensions(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte** extensions, nuint* num_extensions); /// To be documented. - [NativeName("Src", "Line 1112, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1119, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_declared_extensions")] public unsafe partial Result CompilerGetDeclaredExtensions(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte** extensions, ref nuint num_extensions); /// To be documented. - [NativeName("Src", "Line 1115, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1122, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_remapped_declared_block_name")] public unsafe partial byte* CompilerGetRemappedDeclaredBlockName(Compiler* compiler, uint id); /// To be documented. - [NativeName("Src", "Line 1115, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1122, Column 29 in spirv_cross_c.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvc_compiler_get_remapped_declared_block_name")] public unsafe partial string CompilerGetRemappedDeclaredBlockNameS(Compiler* compiler, uint id); /// To be documented. - [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1123, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_buffer_block_decorations")] public unsafe partial Result CompilerGetBufferBlockDecorations(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.SPIRV.Decoration** decorations, nuint* num_decorations); /// To be documented. - [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1123, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_buffer_block_decorations")] public unsafe partial Result CompilerGetBufferBlockDecorations(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.SPIRV.Decoration** decorations, ref nuint num_decorations); /// To be documented. - [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1123, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_buffer_block_decorations")] public unsafe partial Result CompilerGetBufferBlockDecorations(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.SPIRV.Decoration* decorations, nuint* num_decorations); /// To be documented. - [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1123, Column 29 in spirv_cross_c.h")] [NativeApi(EntryPoint = "spvc_compiler_get_buffer_block_decorations")] public unsafe partial Result CompilerGetBufferBlockDecorations(Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.SPIRV.Decoration* decorations, ref nuint num_decorations); /// To be documented. - [NativeName("Src", "Line 804, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 811, Column 29 in spirv_cross_c.h")] public unsafe Result CompilerCompile(Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] string[] sourceSa) { // StringArrayOverloader diff --git a/src/SPIRV/Silk.NET.SPIRV.Cross/CrossOverloads.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Cross/CrossOverloads.gen.cs index da6f2a5958..66eb89a702 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Cross/CrossOverloads.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Cross/CrossOverloads.gen.cs @@ -73,7 +73,7 @@ public static unsafe void GetVersion(this Cross thisApi, Span major, Span< } /// To be documented. - [NativeName("Src", "Line 338, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 339, Column 22 in spirv_cross_c.h")] public static unsafe void MslVertexAttributeInit(this Cross thisApi, Span attr) { // SpanOverloader @@ -81,7 +81,7 @@ public static unsafe void MslVertexAttributeInit(this Cross thisApi, SpanTo be documented. - [NativeName("Src", "Line 353, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 354, Column 22 in spirv_cross_c.h")] public static unsafe void MslShaderInterfaceVarInit(this Cross thisApi, Span var) { // SpanOverloader @@ -89,7 +89,7 @@ public static unsafe void MslShaderInterfaceVarInit(this Cross thisApi, SpanTo be documented. - [NativeName("Src", "Line 357, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 358, Column 22 in spirv_cross_c.h")] public static unsafe void MslShaderInputInit(this Cross thisApi, Span input) { // SpanOverloader @@ -97,7 +97,7 @@ public static unsafe void MslShaderInputInit(this Cross thisApi, SpanTo be documented. - [NativeName("Src", "Line 382, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 383, Column 22 in spirv_cross_c.h")] public static unsafe void MslShaderInterfaceVarInit2(this Cross thisApi, Span var) { // SpanOverloader @@ -105,7 +105,7 @@ public static unsafe void MslShaderInterfaceVarInit2(this Cross thisApi, SpanTo be documented. - [NativeName("Src", "Line 412, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 413, Column 22 in spirv_cross_c.h")] public static unsafe void MslResourceBindingInit(this Cross thisApi, Span binding) { // SpanOverloader @@ -113,7 +113,7 @@ public static unsafe void MslResourceBindingInit(this Cross thisApi, SpanTo be documented. - [NativeName("Src", "Line 413, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 414, Column 22 in spirv_cross_c.h")] public static unsafe void MslResourceBindingInit2(this Cross thisApi, Span binding) { // SpanOverloader @@ -121,7 +121,7 @@ public static unsafe void MslResourceBindingInit2(this Cross thisApi, SpanTo be documented. - [NativeName("Src", "Line 560, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 561, Column 22 in spirv_cross_c.h")] public static unsafe void MslConstexprSamplerInit(this Cross thisApi, Span sampler) { // SpanOverloader @@ -129,7 +129,7 @@ public static unsafe void MslConstexprSamplerInit(this Cross thisApi, SpanTo be documented. - [NativeName("Src", "Line 580, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 581, Column 22 in spirv_cross_c.h")] public static unsafe void MslSamplerYcbcrConversionInit(this Cross thisApi, Span conv) { // SpanOverloader @@ -137,7 +137,7 @@ public static unsafe void MslSamplerYcbcrConversionInit(this Cross thisApi, Span } /// To be documented. - [NativeName("Src", "Line 618, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 619, Column 22 in spirv_cross_c.h")] public static unsafe void HlslResourceBindingInit(this Cross thisApi, Span binding) { // SpanOverloader @@ -145,7 +145,7 @@ public static unsafe void HlslResourceBindingInit(this Cross thisApi, SpanTo be documented. - [NativeName("Src", "Line 774, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 781, Column 22 in spirv_cross_c.h")] public static unsafe void ContextSetErrorCallback(this Cross thisApi, Context* context, PfnErrorCallback cb, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -153,7 +153,7 @@ public static unsafe void ContextSetErrorCallback(this Cross thisApi, Contex } /// To be documented. - [NativeName("Src", "Line 777, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 784, Column 29 in spirv_cross_c.h")] public static unsafe Result ContextParseSpirv(this Cross thisApi, Context* context, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan spirv, nuint word_count, ParsedIr** parsed_ir) { // SpanOverloader @@ -161,7 +161,7 @@ public static unsafe Result ContextParseSpirv(this Cross thisApi, Context* conte } /// To be documented. - [NativeName("Src", "Line 777, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 784, Column 29 in spirv_cross_c.h")] public static unsafe Result ContextParseSpirv(this Cross thisApi, Context* context, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan spirv, nuint word_count, ref ParsedIr* parsed_ir) { // SpanOverloader @@ -169,7 +169,7 @@ public static unsafe Result ContextParseSpirv(this Cross thisApi, Context* conte } /// To be documented. - [NativeName("Src", "Line 807, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 814, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerAddHeaderLine(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan line) { // SpanOverloader @@ -177,7 +177,7 @@ public static unsafe Result CompilerAddHeaderLine(this Cross thisApi, Compiler* } /// To be documented. - [NativeName("Src", "Line 808, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 815, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerRequireExtension(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan ext) { // SpanOverloader @@ -185,7 +185,7 @@ public static unsafe Result CompilerRequireExtension(this Cross thisApi, Compile } /// To be documented. - [NativeName("Src", "Line 823, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 830, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerHlslSetRootConstantsLayout(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan constant_info, nuint count) { // SpanOverloader @@ -193,7 +193,7 @@ public static unsafe Result CompilerHlslSetRootConstantsLayout(this Cross thisAp } /// To be documented. - [NativeName("Src", "Line 826, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 833, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerHlslAddVertexAttributeRemap(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan remap, nuint remaps) { // SpanOverloader @@ -201,7 +201,7 @@ public static unsafe Result CompilerHlslAddVertexAttributeRemap(this Cross thisA } /// To be documented. - [NativeName("Src", "Line 834, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 841, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerHlslAddResourceBinding(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan binding) { // SpanOverloader @@ -209,7 +209,7 @@ public static unsafe Result CompilerHlslAddResourceBinding(this Cross thisApi, C } /// To be documented. - [NativeName("Src", "Line 855, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 862, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslAddVertexAttribute(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan attrs) { // SpanOverloader @@ -217,7 +217,7 @@ public static unsafe Result CompilerMslAddVertexAttribute(this Cross thisApi, Co } /// To be documented. - [NativeName("Src", "Line 858, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 865, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslAddResourceBinding(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan binding) { // SpanOverloader @@ -225,7 +225,7 @@ public static unsafe Result CompilerMslAddResourceBinding(this Cross thisApi, Co } /// To be documented. - [NativeName("Src", "Line 860, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 867, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslAddResourceBinding2(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan binding) { // SpanOverloader @@ -233,7 +233,7 @@ public static unsafe Result CompilerMslAddResourceBinding2(this Cross thisApi, C } /// To be documented. - [NativeName("Src", "Line 863, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 870, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslAddShaderInput(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan input) { // SpanOverloader @@ -241,7 +241,7 @@ public static unsafe Result CompilerMslAddShaderInput(this Cross thisApi, Compil } /// To be documented. - [NativeName("Src", "Line 865, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 872, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslAddShaderInput2(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan input) { // SpanOverloader @@ -249,7 +249,7 @@ public static unsafe Result CompilerMslAddShaderInput2(this Cross thisApi, Compi } /// To be documented. - [NativeName("Src", "Line 868, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 875, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslAddShaderOutput(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan output) { // SpanOverloader @@ -257,7 +257,7 @@ public static unsafe Result CompilerMslAddShaderOutput(this Cross thisApi, Compi } /// To be documented. - [NativeName("Src", "Line 870, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 877, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslAddShaderOutput2(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan output) { // SpanOverloader @@ -265,7 +265,7 @@ public static unsafe Result CompilerMslAddShaderOutput2(this Cross thisApi, Comp } /// To be documented. - [NativeName("Src", "Line 884, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 891, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslRemapConstexprSampler(this Cross thisApi, Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan sampler) { // SpanOverloader @@ -273,7 +273,7 @@ public static unsafe Result CompilerMslRemapConstexprSampler(this Cross thisApi, } /// To be documented. - [NativeName("Src", "Line 885, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 892, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslRemapConstexprSamplerByBinding(this Cross thisApi, Compiler* compiler, uint desc_set, uint binding, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan sampler) { // SpanOverloader @@ -281,7 +281,7 @@ public static unsafe Result CompilerMslRemapConstexprSamplerByBinding(this Cross } /// To be documented. - [NativeName("Src", "Line 886, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 893, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslRemapConstexprSamplerYcbcr(this Cross thisApi, Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslConstexprSampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan conv) { // SpanOverloader @@ -289,7 +289,7 @@ public static unsafe Result CompilerMslRemapConstexprSamplerYcbcr(this Cross thi } /// To be documented. - [NativeName("Src", "Line 886, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 893, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslRemapConstexprSamplerYcbcr(this Cross thisApi, Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslSamplerYcbcrConversion* conv) { // SpanOverloader @@ -297,7 +297,7 @@ public static unsafe Result CompilerMslRemapConstexprSamplerYcbcr(this Cross thi } /// To be documented. - [NativeName("Src", "Line 886, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 893, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslRemapConstexprSamplerYcbcr(this Cross thisApi, Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan conv) { // SpanOverloader @@ -305,7 +305,7 @@ public static unsafe Result CompilerMslRemapConstexprSamplerYcbcr(this Cross thi } /// To be documented. - [NativeName("Src", "Line 887, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 894, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslRemapConstexprSamplerByBindingYcbcr(this Cross thisApi, Compiler* compiler, uint desc_set, uint binding, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslConstexprSampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan conv) { // SpanOverloader @@ -313,7 +313,7 @@ public static unsafe Result CompilerMslRemapConstexprSamplerByBindingYcbcr(this } /// To be documented. - [NativeName("Src", "Line 887, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 894, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslRemapConstexprSamplerByBindingYcbcr(this Cross thisApi, Compiler* compiler, uint desc_set, uint binding, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MslSamplerYcbcrConversion* conv) { // SpanOverloader @@ -321,7 +321,7 @@ public static unsafe Result CompilerMslRemapConstexprSamplerByBindingYcbcr(this } /// To be documented. - [NativeName("Src", "Line 887, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 894, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslRemapConstexprSamplerByBindingYcbcr(this Cross thisApi, Compiler* compiler, uint desc_set, uint binding, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan conv) { // SpanOverloader @@ -329,7 +329,7 @@ public static unsafe Result CompilerMslRemapConstexprSamplerByBindingYcbcr(this } /// To be documented. - [NativeName("Src", "Line 897, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 904, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerMslSetCombinedSamplerSuffix(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan suffix) { // SpanOverloader @@ -337,7 +337,7 @@ public static unsafe Result CompilerMslSetCombinedSamplerSuffix(this Cross thisA } /// To be documented. - [NativeName("Src", "Line 910, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 917, Column 29 in spirv_cross_c.h")] public static unsafe Result ResourcesGetResourceListForType(this Cross thisApi, Resources* resources, ResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectedResource** resource_list, Span resource_size) { // SpanOverloader @@ -345,7 +345,7 @@ public static unsafe Result ResourcesGetResourceListForType(this Cross thisApi, } /// To be documented. - [NativeName("Src", "Line 910, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 917, Column 29 in spirv_cross_c.h")] public static unsafe Result ResourcesGetResourceListForType(this Cross thisApi, Resources* resources, ResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectedResource* resource_list, Span resource_size) { // SpanOverloader @@ -353,7 +353,7 @@ public static unsafe Result ResourcesGetResourceListForType(this Cross thisApi, } /// To be documented. - [NativeName("Src", "Line 914, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 921, Column 29 in spirv_cross_c.h")] public static unsafe Result ResourcesGetBuiltinResourceListForType(this Cross thisApi, Resources* resources, BuiltinResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectedBuiltinResource** resource_list, Span resource_size) { // SpanOverloader @@ -361,7 +361,7 @@ public static unsafe Result ResourcesGetBuiltinResourceListForType(this Cross th } /// To be documented. - [NativeName("Src", "Line 914, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 921, Column 29 in spirv_cross_c.h")] public static unsafe Result ResourcesGetBuiltinResourceListForType(this Cross thisApi, Resources* resources, BuiltinResourceType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectedBuiltinResource* resource_list, Span resource_size) { // SpanOverloader @@ -369,7 +369,7 @@ public static unsafe Result ResourcesGetBuiltinResourceListForType(this Cross th } /// To be documented. - [NativeName("Src", "Line 925, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 932, Column 22 in spirv_cross_c.h")] public static unsafe void CompilerSetDecorationString(this Cross thisApi, Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan argument) { // SpanOverloader @@ -377,7 +377,7 @@ public static unsafe void CompilerSetDecorationString(this Cross thisApi, Compil } /// To be documented. - [NativeName("Src", "Line 927, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 934, Column 22 in spirv_cross_c.h")] public static unsafe void CompilerSetName(this Cross thisApi, Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan argument) { // SpanOverloader @@ -385,7 +385,7 @@ public static unsafe void CompilerSetName(this Cross thisApi, Compiler* compiler } /// To be documented. - [NativeName("Src", "Line 930, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 937, Column 22 in spirv_cross_c.h")] public static unsafe void CompilerSetMemberDecorationString(this Cross thisApi, Compiler* compiler, uint id, uint member_index, Silk.NET.SPIRV.Decoration decoration, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan argument) { // SpanOverloader @@ -393,7 +393,7 @@ public static unsafe void CompilerSetMemberDecorationString(this Cross thisApi, } /// To be documented. - [NativeName("Src", "Line 933, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 940, Column 22 in spirv_cross_c.h")] public static unsafe void CompilerSetMemberName(this Cross thisApi, Compiler* compiler, uint id, uint member_index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan argument) { // SpanOverloader @@ -401,7 +401,7 @@ public static unsafe void CompilerSetMemberName(this Cross thisApi, Compiler* co } /// To be documented. - [NativeName("Src", "Line 956, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetEntryPoints(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EntryPoint** entry_points, Span num_entry_points) { // SpanOverloader @@ -409,7 +409,7 @@ public static unsafe Result CompilerGetEntryPoints(this Cross thisApi, Compiler* } /// To be documented. - [NativeName("Src", "Line 956, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetEntryPoints(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly EntryPoint* entry_points, Span num_entry_points) { // SpanOverloader @@ -417,7 +417,7 @@ public static unsafe Result CompilerGetEntryPoints(this Cross thisApi, Compiler* } /// To be documented. - [NativeName("Src", "Line 959, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 966, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerSetEntryPoint(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, Silk.NET.SPIRV.ExecutionModel model) { // SpanOverloader @@ -425,7 +425,7 @@ public static unsafe Result CompilerSetEntryPoint(this Cross thisApi, Compiler* } /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerRenameEntryPoint(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan new_name, Silk.NET.SPIRV.ExecutionModel model) { // SpanOverloader @@ -433,7 +433,7 @@ public static unsafe Result CompilerRenameEntryPoint(this Cross thisApi, Compile } /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerRenameEntryPoint(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* new_name, Silk.NET.SPIRV.ExecutionModel model) { // SpanOverloader @@ -441,7 +441,7 @@ public static unsafe Result CompilerRenameEntryPoint(this Cross thisApi, Compile } /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerRenameEntryPoint(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan new_name, Silk.NET.SPIRV.ExecutionModel model) { // SpanOverloader @@ -449,7 +449,7 @@ public static unsafe Result CompilerRenameEntryPoint(this Cross thisApi, Compile } /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerRenameEntryPoint(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string new_name, Silk.NET.SPIRV.ExecutionModel model) { // SpanOverloader @@ -457,7 +457,7 @@ public static unsafe Result CompilerRenameEntryPoint(this Cross thisApi, Compile } /// To be documented. - [NativeName("Src", "Line 961, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 968, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerRenameEntryPoint(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string old_name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan new_name, Silk.NET.SPIRV.ExecutionModel model) { // SpanOverloader @@ -465,7 +465,7 @@ public static unsafe Result CompilerRenameEntryPoint(this Cross thisApi, Compile } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 970, Column 29 in spirv_cross_c.h")] public static unsafe byte* CompilerGetCleansedEntryPointName(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, Silk.NET.SPIRV.ExecutionModel model) { // SpanOverloader @@ -473,7 +473,7 @@ public static unsafe Result CompilerRenameEntryPoint(this Cross thisApi, Compile } /// To be documented. - [NativeName("Src", "Line 969, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 976, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetExecutionModes(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.SPIRV.ExecutionMode** modes, Span num_modes) { // SpanOverloader @@ -481,7 +481,7 @@ public static unsafe Result CompilerGetExecutionModes(this Cross thisApi, Compil } /// To be documented. - [NativeName("Src", "Line 969, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 976, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetExecutionModes(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.SPIRV.ExecutionMode* modes, Span num_modes) { // SpanOverloader @@ -489,7 +489,7 @@ public static unsafe Result CompilerGetExecutionModes(this Cross thisApi, Compil } /// To be documented. - [NativeName("Src", "Line 1015, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1022, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetDeclaredStructSize(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* struct_type, Span size) { // SpanOverloader @@ -497,7 +497,7 @@ public static unsafe Result CompilerGetDeclaredStructSize(this Cross thisApi, Co } /// To be documented. - [NativeName("Src", "Line 1016, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1023, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetDeclaredStructSizeRuntimeArray(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* struct_type, nuint array_size, Span size) { // SpanOverloader @@ -505,7 +505,7 @@ public static unsafe Result CompilerGetDeclaredStructSizeRuntimeArray(this Cross } /// To be documented. - [NativeName("Src", "Line 1018, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1025, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetDeclaredStructMemberSize(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, Span size) { // SpanOverloader @@ -513,7 +513,7 @@ public static unsafe Result CompilerGetDeclaredStructMemberSize(this Cross thisA } /// To be documented. - [NativeName("Src", "Line 1020, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1027, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerTypeStructMemberOffset(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, Span offset) { // SpanOverloader @@ -521,7 +521,7 @@ public static unsafe Result CompilerTypeStructMemberOffset(this Cross thisApi, C } /// To be documented. - [NativeName("Src", "Line 1022, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1029, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerTypeStructMemberArrayStride(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, Span stride) { // SpanOverloader @@ -529,7 +529,7 @@ public static unsafe Result CompilerTypeStructMemberArrayStride(this Cross thisA } /// To be documented. - [NativeName("Src", "Line 1024, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1031, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerTypeStructMemberMatrixStride(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CrossType* type, uint index, Span stride) { // SpanOverloader @@ -537,7 +537,7 @@ public static unsafe Result CompilerTypeStructMemberMatrixStride(this Cross this } /// To be documented. - [NativeName("Src", "Line 1031, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1038, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerBuildDummySamplerForCombinedImages(this Cross thisApi, Compiler* compiler, Span id) { // SpanOverloader @@ -545,7 +545,7 @@ public static unsafe Result CompilerBuildDummySamplerForCombinedImages(this Cros } /// To be documented. - [NativeName("Src", "Line 1033, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1040, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetCombinedImageSamplers(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CombinedImageSampler** samplers, Span num_samplers) { // SpanOverloader @@ -553,7 +553,7 @@ public static unsafe Result CompilerGetCombinedImageSamplers(this Cross thisApi, } /// To be documented. - [NativeName("Src", "Line 1033, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1040, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetCombinedImageSamplers(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly CombinedImageSampler* samplers, Span num_samplers) { // SpanOverloader @@ -561,7 +561,7 @@ public static unsafe Result CompilerGetCombinedImageSamplers(this Cross thisApi, } /// To be documented. - [NativeName("Src", "Line 1041, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1048, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetSpecializationConstants(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SpecializationConstant** constants, Span num_constants) { // SpanOverloader @@ -569,7 +569,7 @@ public static unsafe Result CompilerGetSpecializationConstants(this Cross thisAp } /// To be documented. - [NativeName("Src", "Line 1041, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1048, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetSpecializationConstants(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly SpecializationConstant* constants, Span num_constants) { // SpanOverloader @@ -577,7 +577,7 @@ public static unsafe Result CompilerGetSpecializationConstants(this Cross thisAp } /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this Cross thisApi, Compiler* compiler, SpecializationConstant* x, SpecializationConstant* y, Span z) { // SpanOverloader @@ -585,7 +585,7 @@ public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this C } /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this Cross thisApi, Compiler* compiler, SpecializationConstant* x, Span y, SpecializationConstant* z) { // SpanOverloader @@ -593,7 +593,7 @@ public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this C } /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this Cross thisApi, Compiler* compiler, SpecializationConstant* x, Span y, Span z) { // SpanOverloader @@ -601,7 +601,7 @@ public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this C } /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this Cross thisApi, Compiler* compiler, Span x, SpecializationConstant* y, SpecializationConstant* z) { // SpanOverloader @@ -609,7 +609,7 @@ public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this C } /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this Cross thisApi, Compiler* compiler, Span x, SpecializationConstant* y, Span z) { // SpanOverloader @@ -617,7 +617,7 @@ public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this C } /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this Cross thisApi, Compiler* compiler, Span x, Span y, SpecializationConstant* z) { // SpanOverloader @@ -625,7 +625,7 @@ public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this C } /// To be documented. - [NativeName("Src", "Line 1047, Column 34 in spirv_cross_c.h")] + [NativeName("Src", "Line 1054, Column 34 in spirv_cross_c.h")] public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this Cross thisApi, Compiler* compiler, Span x, Span y, Span z) { // SpanOverloader @@ -633,7 +633,7 @@ public static unsafe uint CompilerGetWorkGroupSizeSpecializationConstants(this C } /// To be documented. - [NativeName("Src", "Line 1056, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1063, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetActiveBufferRanges(this Cross thisApi, Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BufferRange** ranges, Span num_ranges) { // SpanOverloader @@ -641,7 +641,7 @@ public static unsafe Result CompilerGetActiveBufferRanges(this Cross thisApi, Co } /// To be documented. - [NativeName("Src", "Line 1056, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1063, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetActiveBufferRanges(this Cross thisApi, Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly BufferRange* ranges, Span num_ranges) { // SpanOverloader @@ -649,7 +649,7 @@ public static unsafe Result CompilerGetActiveBufferRanges(this Cross thisApi, Co } /// To be documented. - [NativeName("Src", "Line 1076, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1083, Column 22 in spirv_cross_c.h")] public static unsafe void ConstantGetSubconstants(this Cross thisApi, Constant* constant, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint** constituents, Span count) { // SpanOverloader @@ -657,7 +657,7 @@ public static unsafe void ConstantGetSubconstants(this Cross thisApi, Constant* } /// To be documented. - [NativeName("Src", "Line 1076, Column 22 in spirv_cross_c.h")] + [NativeName("Src", "Line 1083, Column 22 in spirv_cross_c.h")] public static unsafe void ConstantGetSubconstants(this Cross thisApi, Constant* constant, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly uint* constituents, Span count) { // SpanOverloader @@ -665,7 +665,7 @@ public static unsafe void ConstantGetSubconstants(this Cross thisApi, Constant* } /// To be documented. - [NativeName("Src", "Line 1100, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1107, Column 27 in spirv_cross_c.h")] public static unsafe byte CompilerGetBinaryOffsetForDecoration(this Cross thisApi, Compiler* compiler, uint id, Silk.NET.SPIRV.Decoration decoration, Span word_offset) { // SpanOverloader @@ -673,7 +673,7 @@ public static unsafe byte CompilerGetBinaryOffsetForDecoration(this Cross thisAp } /// To be documented. - [NativeName("Src", "Line 1106, Column 27 in spirv_cross_c.h")] + [NativeName("Src", "Line 1113, Column 27 in spirv_cross_c.h")] public static unsafe byte CompilerBufferGetHlslCounterBuffer(this Cross thisApi, Compiler* compiler, uint id, Span counter_id) { // SpanOverloader @@ -681,7 +681,7 @@ public static unsafe byte CompilerBufferGetHlslCounterBuffer(this Cross thisApi, } /// To be documented. - [NativeName("Src", "Line 1109, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetDeclaredCapabilities(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.SPIRV.Capability** capabilities, Span num_capabilities) { // SpanOverloader @@ -689,7 +689,7 @@ public static unsafe Result CompilerGetDeclaredCapabilities(this Cross thisApi, } /// To be documented. - [NativeName("Src", "Line 1109, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetDeclaredCapabilities(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.SPIRV.Capability* capabilities, Span num_capabilities) { // SpanOverloader @@ -697,7 +697,7 @@ public static unsafe Result CompilerGetDeclaredCapabilities(this Cross thisApi, } /// To be documented. - [NativeName("Src", "Line 1112, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1119, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetDeclaredExtensions(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte*** extensions, Span num_extensions) { // SpanOverloader @@ -705,7 +705,7 @@ public static unsafe Result CompilerGetDeclaredExtensions(this Cross thisApi, Co } /// To be documented. - [NativeName("Src", "Line 1112, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1119, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetDeclaredExtensions(this Cross thisApi, Compiler* compiler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte** extensions, Span num_extensions) { // SpanOverloader @@ -713,7 +713,7 @@ public static unsafe Result CompilerGetDeclaredExtensions(this Cross thisApi, Co } /// To be documented. - [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1123, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetBufferBlockDecorations(this Cross thisApi, Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.SPIRV.Decoration** decorations, Span num_decorations) { // SpanOverloader @@ -721,7 +721,7 @@ public static unsafe Result CompilerGetBufferBlockDecorations(this Cross thisApi } /// To be documented. - [NativeName("Src", "Line 1116, Column 29 in spirv_cross_c.h")] + [NativeName("Src", "Line 1123, Column 29 in spirv_cross_c.h")] public static unsafe Result CompilerGetBufferBlockDecorations(this Cross thisApi, Compiler* compiler, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.SPIRV.Decoration* decorations, Span num_decorations) { // SpanOverloader diff --git a/src/SPIRV/Silk.NET.SPIRV.Cross/Enums/CompilerOption.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Cross/Enums/CompilerOption.gen.cs index e9a26c608f..736399cd93 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Cross/Enums/CompilerOption.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Cross/Enums/CompilerOption.gen.cs @@ -200,6 +200,12 @@ public enum CompilerOption : int HlslUseEntryPointName = 0x400005A, [NativeName("Name", "SPVC_COMPILER_OPTION_HLSL_PRESERVE_STRUCTURED_BUFFERS")] HlslPreserveStructuredBuffers = 0x400005B, + [NativeName("Name", "SPVC_COMPILER_OPTION_MSL_AUTO_DISABLE_RASTERIZATION")] + MslAutoDisableRasterization = 0x800005C, + [NativeName("Name", "SPVC_COMPILER_OPTION_MSL_ENABLE_POINT_SIZE_DEFAULT")] + MslEnablePointSizeDefault = 0x800005D, + [NativeName("Name", "SPVC_COMPILER_OPTION_HLSL_USER_SEMANTIC")] + HlslUserSemantic = 0x400005E, [NativeName("Name", "SPVC_COMPILER_OPTION_INT_MAX")] IntMax = 0x7FFFFFFF, } diff --git a/src/SPIRV/Silk.NET.SPIRV.Cross/Enums/ResourceType.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Cross/Enums/ResourceType.gen.cs index 48ec266440..239cec9a69 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Cross/Enums/ResourceType.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Cross/Enums/ResourceType.gen.cs @@ -44,6 +44,8 @@ public enum ResourceType : int ShaderRecordBuffer = 0xE, [NativeName("Name", "SPVC_RESOURCE_TYPE_GL_PLAIN_UNIFORM")] GLPlainUniform = 0xF, + [NativeName("Name", "SPVC_RESOURCE_TYPE_TENSOR")] + Tensor = 0x10, [NativeName("Name", "SPVC_RESOURCE_TYPE_INT_MAX")] IntMax = 0x7FFFFFFF, } diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL330C1.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL331C1.gen.cs similarity index 81% rename from src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL330C1.gen.cs rename to src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL331C1.gen.cs index 92815e102a..ec5ba201d3 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL330C1.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL331C1.gen.cs @@ -10,8 +10,8 @@ namespace Silk.NET.SPIRV.Reflect { [Flags] - [NativeName("Name", "__AnonymousEnum_spirv_reflect_L330_C1")] - public enum AnonymousEnumSpirvReflectL330C1 : int + [NativeName("Name", "__AnonymousEnum_spirv_reflect_L331_C1")] + public enum AnonymousEnumSpirvReflectL331C1 : int { [NativeName("Name", "")] None = 0, diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL335C1.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL336C1.gen.cs similarity index 82% rename from src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL335C1.gen.cs rename to src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL336C1.gen.cs index 7c0f6253ff..6b6cbcfd79 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL335C1.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/AnonymousEnumSpirvReflectL336C1.gen.cs @@ -9,8 +9,8 @@ namespace Silk.NET.SPIRV.Reflect { - [NativeName("Name", "__AnonymousEnum_spirv_reflect_L335_C1")] - public enum AnonymousEnumSpirvReflectL335C1 : int + [NativeName("Name", "__AnonymousEnum_spirv_reflect_L336_C1")] + public enum AnonymousEnumSpirvReflectL336C1 : int { [NativeName("Name", "SPV_REFLECT_BINDING_NUMBER_DONT_CHANGE")] BindingNumberDontChange = unchecked((int) 0xFFFFFFFFFFFFFFFF), diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/Generator.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/Generator.gen.cs index add3cd0d8b..8bbfe085de 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/Generator.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Enums/Generator.gen.cs @@ -32,5 +32,7 @@ public enum Generator : int WineVkd3DShaderCompiler = 0x12, [NativeName("Name", "SPV_REFLECT_GENERATOR_CLAY_CLAY_SHADER_COMPILER")] ClayClayShaderCompiler = 0x13, + [NativeName("Name", "SPV_REFLECT_GENERATOR_SLANG_SHADER_COMPILER")] + SlangShaderCompiler = 0x28, } } diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Reflect.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Reflect.gen.cs index 9dcb6be2c9..e354bedc84 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Reflect.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Reflect.gen.cs @@ -18,2234 +18,2234 @@ public unsafe partial class Reflect : NativeAPI { /// To be documented. - [NativeName("Src", "Line 636, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 656, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectCreateShaderModule")] public unsafe partial Result CreateShaderModule(nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* p_code, ReflectShaderModule* p_module); /// To be documented. - [NativeName("Src", "Line 636, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 656, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectCreateShaderModule")] public unsafe partial Result CreateShaderModule(nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* p_code, ref ReflectShaderModule p_module); /// To be documented. - [NativeName("Src", "Line 636, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 656, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectCreateShaderModule")] public unsafe partial Result CreateShaderModule(nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 p_code, ReflectShaderModule* p_module) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 636, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 656, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectCreateShaderModule")] public partial Result CreateShaderModule(nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 p_code, ref ReflectShaderModule p_module) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 651, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 671, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectCreateShaderModule2")] public unsafe partial Result CreateShaderModule2(uint flags, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* p_code, ReflectShaderModule* p_module); /// To be documented. - [NativeName("Src", "Line 651, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 671, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectCreateShaderModule2")] public unsafe partial Result CreateShaderModule2(uint flags, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* p_code, ref ReflectShaderModule p_module); /// To be documented. - [NativeName("Src", "Line 651, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 671, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectCreateShaderModule2")] public unsafe partial Result CreateShaderModule2(uint flags, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 p_code, ReflectShaderModule* p_module) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 651, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 671, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectCreateShaderModule2")] public partial Result CreateShaderModule2(uint flags, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 p_code, ref ReflectShaderModule p_module) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 659, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 679, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetShaderModule")] public unsafe partial Result GetShaderModule(nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* p_code, ReflectShaderModule* p_module); /// To be documented. - [NativeName("Src", "Line 659, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 679, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetShaderModule")] public unsafe partial Result GetShaderModule(nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* p_code, ref ReflectShaderModule p_module); /// To be documented. - [NativeName("Src", "Line 659, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 679, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetShaderModule")] public unsafe partial Result GetShaderModule(nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 p_code, ReflectShaderModule* p_module) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 659, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 679, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetShaderModule")] public partial Result GetShaderModule(nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 p_code, ref ReflectShaderModule p_module) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 671, Column 6 in spirv_reflect.h")] + [NativeName("Src", "Line 691, Column 6 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectDestroyShaderModule")] public unsafe partial void DestroyShaderModule(ReflectShaderModule* p_module); /// To be documented. - [NativeName("Src", "Line 671, Column 6 in spirv_reflect.h")] + [NativeName("Src", "Line 691, Column 6 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectDestroyShaderModule")] public partial void DestroyShaderModule(ref ReflectShaderModule p_module); /// To be documented. - [NativeName("Src", "Line 680, Column 10 in spirv_reflect.h")] + [NativeName("Src", "Line 700, Column 10 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetCodeSize")] public unsafe partial uint GetCodeSize([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module); /// To be documented. - [NativeName("Src", "Line 680, Column 10 in spirv_reflect.h")] + [NativeName("Src", "Line 700, Column 10 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetCodeSize")] public partial uint GetCodeSize([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module); /// To be documented. - [NativeName("Src", "Line 689, Column 17 in spirv_reflect.h")] + [NativeName("Src", "Line 709, Column 17 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetCode")] public unsafe partial uint* GetCode([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module); /// To be documented. - [NativeName("Src", "Line 689, Column 17 in spirv_reflect.h")] + [NativeName("Src", "Line 709, Column 17 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetCode")] public unsafe partial uint* GetCode([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module); /// To be documented. - [NativeName("Src", "Line 698, Column 29 in spirv_reflect.h")] + [NativeName("Src", "Line 718, Column 29 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPoint")] public unsafe partial EntryPoint* GetEntryPoint([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point); /// To be documented. - [NativeName("Src", "Line 698, Column 29 in spirv_reflect.h")] + [NativeName("Src", "Line 718, Column 29 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPoint")] public unsafe partial EntryPoint* GetEntryPoint([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point); /// To be documented. - [NativeName("Src", "Line 698, Column 29 in spirv_reflect.h")] + [NativeName("Src", "Line 718, Column 29 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPoint")] public unsafe partial EntryPoint* GetEntryPoint([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point); /// To be documented. - [NativeName("Src", "Line 698, Column 29 in spirv_reflect.h")] + [NativeName("Src", "Line 718, Column 29 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPoint")] public unsafe partial EntryPoint* GetEntryPoint([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point); /// To be documented. - [NativeName("Src", "Line 698, Column 29 in spirv_reflect.h")] + [NativeName("Src", "Line 718, Column 29 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPoint")] public unsafe partial EntryPoint* GetEntryPoint([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point); /// To be documented. - [NativeName("Src", "Line 698, Column 29 in spirv_reflect.h")] + [NativeName("Src", "Line 718, Column 29 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPoint")] public unsafe partial EntryPoint* GetEntryPoint([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point); /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorBindings")] public unsafe partial Result EnumerateDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorBindings")] public unsafe partial Result EnumerateDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorBindings")] public unsafe partial Result EnumerateDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorBindings")] public unsafe partial Result EnumerateDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorBindings")] public unsafe partial Result EnumerateDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorBindings")] public unsafe partial Result EnumerateDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorBindings")] public unsafe partial Result EnumerateDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorBindings")] public unsafe partial Result EnumerateDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, DescriptorBinding** pp_bindings); /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorBindings")] public unsafe partial Result EnumerateEntryPointDescriptorBindings([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref DescriptorBinding* pp_bindings); /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorSets")] public unsafe partial Result EnumerateDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorSets")] public unsafe partial Result EnumerateDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorSets")] public unsafe partial Result EnumerateDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorSets")] public unsafe partial Result EnumerateDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorSets")] public unsafe partial Result EnumerateDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorSets")] public unsafe partial Result EnumerateDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorSets")] public unsafe partial Result EnumerateDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateDescriptorSets")] public unsafe partial Result EnumerateDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ReflectDescriptorSet** pp_sets); /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointDescriptorSets")] public unsafe partial Result EnumerateEntryPointDescriptorSets([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref ReflectDescriptorSet* pp_sets); /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInterfaceVariables")] public unsafe partial Result EnumerateInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInterfaceVariables")] public unsafe partial Result EnumerateInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInterfaceVariables")] public unsafe partial Result EnumerateInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInterfaceVariables")] public unsafe partial Result EnumerateInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInterfaceVariables")] public unsafe partial Result EnumerateInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInterfaceVariables")] public unsafe partial Result EnumerateInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInterfaceVariables")] public unsafe partial Result EnumerateInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInterfaceVariables")] public unsafe partial Result EnumerateInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInterfaceVariables")] public unsafe partial Result EnumerateEntryPointInterfaceVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInputVariables")] public unsafe partial Result EnumerateInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInputVariables")] public unsafe partial Result EnumerateInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInputVariables")] public unsafe partial Result EnumerateInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInputVariables")] public unsafe partial Result EnumerateInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInputVariables")] public unsafe partial Result EnumerateInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInputVariables")] public unsafe partial Result EnumerateInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInputVariables")] public unsafe partial Result EnumerateInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateInputVariables")] public unsafe partial Result EnumerateInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointInputVariables")] public unsafe partial Result EnumerateEntryPointInputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateOutputVariables")] public unsafe partial Result EnumerateOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateOutputVariables")] public unsafe partial Result EnumerateOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateOutputVariables")] public unsafe partial Result EnumerateOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateOutputVariables")] public unsafe partial Result EnumerateOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateOutputVariables")] public unsafe partial Result EnumerateOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateOutputVariables")] public unsafe partial Result EnumerateOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateOutputVariables")] public unsafe partial Result EnumerateOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateOutputVariables")] public unsafe partial Result EnumerateOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, InterfaceVariable** pp_variables); /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointOutputVariables")] public unsafe partial Result EnumerateEntryPointOutputVariables([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref InterfaceVariable* pp_variables); /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstantBlocks")] public unsafe partial Result EnumeratePushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstantBlocks")] public unsafe partial Result EnumeratePushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstantBlocks")] public unsafe partial Result EnumeratePushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstantBlocks")] public unsafe partial Result EnumeratePushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstantBlocks")] public unsafe partial Result EnumeratePushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstantBlocks")] public unsafe partial Result EnumeratePushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstantBlocks")] public unsafe partial Result EnumeratePushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstantBlocks")] public unsafe partial Result EnumeratePushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstants")] public unsafe partial Result EnumeratePushConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstants")] public unsafe partial Result EnumeratePushConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstants")] public unsafe partial Result EnumeratePushConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstants")] public unsafe partial Result EnumeratePushConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstants")] public unsafe partial Result EnumeratePushConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstants")] public unsafe partial Result EnumeratePushConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstants")] public unsafe partial Result EnumeratePushConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumeratePushConstants")] public unsafe partial Result EnumeratePushConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref uint p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint* p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref uint p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, BlockVariable** pp_blocks); /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateEntryPointPushConstantBlocks")] public unsafe partial Result EnumerateEntryPointPushConstantBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref uint p_count, ref BlockVariable* pp_blocks); /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateSpecializationConstants")] public unsafe partial Result EnumerateSpecializationConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, SpecializationConstant** pp_constants); /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateSpecializationConstants")] public unsafe partial Result EnumerateSpecializationConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint* p_count, ref SpecializationConstant* pp_constants); /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateSpecializationConstants")] public unsafe partial Result EnumerateSpecializationConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, SpecializationConstant** pp_constants); /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateSpecializationConstants")] public unsafe partial Result EnumerateSpecializationConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, ref uint p_count, ref SpecializationConstant* pp_constants); /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateSpecializationConstants")] public unsafe partial Result EnumerateSpecializationConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, SpecializationConstant** pp_constants); /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateSpecializationConstants")] public unsafe partial Result EnumerateSpecializationConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint* p_count, ref SpecializationConstant* pp_constants); /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateSpecializationConstants")] public unsafe partial Result EnumerateSpecializationConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, SpecializationConstant** pp_constants); /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectEnumerateSpecializationConstants")] public unsafe partial Result EnumerateSpecializationConstants([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, ref uint p_count, ref SpecializationConstant* pp_constants); /// To be documented. - [NativeName("Src", "Line 1063, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1083, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetDescriptorBinding")] public unsafe partial DescriptorBinding* GetDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint binding_number, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1063, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1083, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetDescriptorBinding")] public unsafe partial DescriptorBinding* GetDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint binding_number, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1063, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1083, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetDescriptorBinding")] public unsafe partial DescriptorBinding* GetDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint binding_number, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1063, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1083, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetDescriptorBinding")] public unsafe partial DescriptorBinding* GetDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint binding_number, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint binding_number, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint binding_number, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint binding_number, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint binding_number, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint binding_number, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint binding_number, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint binding_number, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint binding_number, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint binding_number, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint binding_number, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint binding_number, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorBinding")] public unsafe partial DescriptorBinding* GetEntryPointDescriptorBinding([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint binding_number, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1120, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1140, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1120, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1140, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1120, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1140, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1120, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1140, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint set_number, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointDescriptorSet")] public unsafe partial ReflectDescriptorSet* GetEntryPointDescriptorSet([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint set_number, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1171, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1191, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableByLocation")] public unsafe partial InterfaceVariable* GetInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1171, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1191, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableByLocation")] public unsafe partial InterfaceVariable* GetInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1171, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1191, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableByLocation")] public unsafe partial InterfaceVariable* GetInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1171, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1191, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableByLocation")] public unsafe partial InterfaceVariable* GetInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1177, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1197, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariable")] public unsafe partial InterfaceVariable* GetInputVariable([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1177, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1197, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariable")] public unsafe partial InterfaceVariable* GetInputVariable([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1177, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1197, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariable")] public unsafe partial InterfaceVariable* GetInputVariable([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1177, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1197, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariable")] public unsafe partial InterfaceVariable* GetInputVariable([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointInputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointInputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1287, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1307, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1287, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1307, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1287, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1307, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1287, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1307, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1293, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1313, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariable")] public unsafe partial InterfaceVariable* GetOutputVariable([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1293, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1313, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariable")] public unsafe partial InterfaceVariable* GetOutputVariable([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1293, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1313, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariable")] public unsafe partial InterfaceVariable* GetOutputVariable([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1293, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1313, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariable")] public unsafe partial InterfaceVariable* GetOutputVariable([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableByLocation")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableByLocation([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointOutputVariableBySemantic")] public unsafe partial InterfaceVariable* GetEntryPointOutputVariableBySemantic([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1400, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1420, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetPushConstantBlock")] public unsafe partial BlockVariable* GetPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint index, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1400, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1420, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetPushConstantBlock")] public unsafe partial BlockVariable* GetPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint index, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1400, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1420, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetPushConstantBlock")] public unsafe partial BlockVariable* GetPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint index, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1400, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1420, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetPushConstantBlock")] public unsafe partial BlockVariable* GetPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint index, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1406, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1426, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetPushConstant")] public unsafe partial BlockVariable* GetPushConstant([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint index, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1406, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1426, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetPushConstant")] public unsafe partial BlockVariable* GetPushConstant([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint index, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1406, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1426, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetPushConstant")] public unsafe partial BlockVariable* GetPushConstant([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint index, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1406, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1426, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetPushConstant")] public unsafe partial BlockVariable* GetPushConstant([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, uint index, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte entry_point, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Result* p_result); /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectGetEntryPointPushConstantBlock")] public unsafe partial BlockVariable* GetEntryPointPushConstantBlock([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, ref Result p_result); /// To be documented. - [NativeName("Src", "Line 1461, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1481, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorBindingNumbers")] public unsafe partial Result ChangeDescriptorBindingNumbers(ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DescriptorBinding* p_binding, uint new_binding_number, uint new_set_number); /// To be documented. - [NativeName("Src", "Line 1461, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1481, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorBindingNumbers")] public unsafe partial Result ChangeDescriptorBindingNumbers(ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DescriptorBinding p_binding, uint new_binding_number, uint new_set_number); /// To be documented. - [NativeName("Src", "Line 1461, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1481, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorBindingNumbers")] public unsafe partial Result ChangeDescriptorBindingNumbers(ref ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DescriptorBinding* p_binding, uint new_binding_number, uint new_set_number); /// To be documented. - [NativeName("Src", "Line 1461, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1481, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorBindingNumbers")] public partial Result ChangeDescriptorBindingNumbers(ref ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DescriptorBinding p_binding, uint new_binding_number, uint new_set_number); /// To be documented. - [NativeName("Src", "Line 1468, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1488, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorBindingNumber")] public unsafe partial Result ChangeDescriptorBindingNumber(ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DescriptorBinding* p_descriptor_binding, uint new_binding_number, uint optional_new_set_number); /// To be documented. - [NativeName("Src", "Line 1468, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1488, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorBindingNumber")] public unsafe partial Result ChangeDescriptorBindingNumber(ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DescriptorBinding p_descriptor_binding, uint new_binding_number, uint optional_new_set_number); /// To be documented. - [NativeName("Src", "Line 1468, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1488, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorBindingNumber")] public unsafe partial Result ChangeDescriptorBindingNumber(ref ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DescriptorBinding* p_descriptor_binding, uint new_binding_number, uint optional_new_set_number); /// To be documented. - [NativeName("Src", "Line 1468, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1488, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorBindingNumber")] public partial Result ChangeDescriptorBindingNumber(ref ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DescriptorBinding p_descriptor_binding, uint new_binding_number, uint optional_new_set_number); /// To be documented. - [NativeName("Src", "Line 1497, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1517, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorSetNumber")] public unsafe partial Result ChangeDescriptorSetNumber(ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectDescriptorSet* p_set, uint new_set_number); /// To be documented. - [NativeName("Src", "Line 1497, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1517, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorSetNumber")] public unsafe partial Result ChangeDescriptorSetNumber(ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectDescriptorSet p_set, uint new_set_number); /// To be documented. - [NativeName("Src", "Line 1497, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1517, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorSetNumber")] public unsafe partial Result ChangeDescriptorSetNumber(ref ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectDescriptorSet* p_set, uint new_set_number); /// To be documented. - [NativeName("Src", "Line 1497, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1517, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeDescriptorSetNumber")] public partial Result ChangeDescriptorSetNumber(ref ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ReflectDescriptorSet p_set, uint new_set_number); /// To be documented. - [NativeName("Src", "Line 1520, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1540, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeInputVariableLocation")] public unsafe partial Result ChangeInputVariableLocation(ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] InterfaceVariable* p_input_variable, uint new_location); /// To be documented. - [NativeName("Src", "Line 1520, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1540, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeInputVariableLocation")] public unsafe partial Result ChangeInputVariableLocation(ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly InterfaceVariable p_input_variable, uint new_location); /// To be documented. - [NativeName("Src", "Line 1520, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1540, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeInputVariableLocation")] public unsafe partial Result ChangeInputVariableLocation(ref ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] InterfaceVariable* p_input_variable, uint new_location); /// To be documented. - [NativeName("Src", "Line 1520, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1540, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeInputVariableLocation")] public partial Result ChangeInputVariableLocation(ref ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly InterfaceVariable p_input_variable, uint new_location); /// To be documented. - [NativeName("Src", "Line 1544, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1564, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeOutputVariableLocation")] public unsafe partial Result ChangeOutputVariableLocation(ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] InterfaceVariable* p_output_variable, uint new_location); /// To be documented. - [NativeName("Src", "Line 1544, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1564, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeOutputVariableLocation")] public unsafe partial Result ChangeOutputVariableLocation(ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly InterfaceVariable p_output_variable, uint new_location); /// To be documented. - [NativeName("Src", "Line 1544, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1564, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeOutputVariableLocation")] public unsafe partial Result ChangeOutputVariableLocation(ref ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] InterfaceVariable* p_output_variable, uint new_location); /// To be documented. - [NativeName("Src", "Line 1544, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1564, Column 18 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectChangeOutputVariableLocation")] public partial Result ChangeOutputVariableLocation(ref ReflectShaderModule p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly InterfaceVariable p_output_variable, uint new_location); /// To be documented. - [NativeName("Src", "Line 1557, Column 13 in spirv_reflect.h")] + [NativeName("Src", "Line 1577, Column 13 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectSourceLanguage")] public unsafe partial byte* SourceLanguage(Silk.NET.SPIRV.SourceLanguage source_lang); /// To be documented. - [NativeName("Src", "Line 1557, Column 13 in spirv_reflect.h")] + [NativeName("Src", "Line 1577, Column 13 in spirv_reflect.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvReflectSourceLanguage")] public partial string SourceLanguageS(Silk.NET.SPIRV.SourceLanguage source_lang); /// To be documented. - [NativeName("Src", "Line 1565, Column 13 in spirv_reflect.h")] + [NativeName("Src", "Line 1585, Column 13 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectBlockVariableTypeName")] public unsafe partial byte* BlockVariableTypeName([Flow(Silk.NET.Core.Native.FlowDirection.In)] BlockVariable* p_var); /// To be documented. - [NativeName("Src", "Line 1565, Column 13 in spirv_reflect.h")] + [NativeName("Src", "Line 1585, Column 13 in spirv_reflect.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvReflectBlockVariableTypeName")] public unsafe partial string BlockVariableTypeNameS([Flow(Silk.NET.Core.Native.FlowDirection.In)] BlockVariable* p_var); /// To be documented. - [NativeName("Src", "Line 1565, Column 13 in spirv_reflect.h")] + [NativeName("Src", "Line 1585, Column 13 in spirv_reflect.h")] [NativeApi(EntryPoint = "spvReflectBlockVariableTypeName")] public unsafe partial byte* BlockVariableTypeName([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly BlockVariable p_var); /// To be documented. - [NativeName("Src", "Line 1565, Column 13 in spirv_reflect.h")] + [NativeName("Src", "Line 1585, Column 13 in spirv_reflect.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "spvReflectBlockVariableTypeName")] public partial string BlockVariableTypeNameS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly BlockVariable p_var); diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/ReflectOverloads.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/ReflectOverloads.gen.cs index 752336e804..86cdd6df10 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/ReflectOverloads.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/ReflectOverloads.gen.cs @@ -17,7 +17,7 @@ namespace Silk.NET.SPIRV.Reflect public static class ReflectOverloads { /// To be documented. - [NativeName("Src", "Line 636, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 656, Column 18 in spirv_reflect.h")] public static unsafe Result CreateShaderModule(this Reflect thisApi, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* p_code, Span p_module) { // SpanOverloader @@ -25,7 +25,7 @@ public static unsafe Result CreateShaderModule(this Reflect thisApi, nuint size, } /// To be documented. - [NativeName("Src", "Line 636, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 656, Column 18 in spirv_reflect.h")] public static unsafe Result CreateShaderModule(this Reflect thisApi, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_code, ReflectShaderModule* p_module) where T0 : unmanaged { // SpanOverloader @@ -33,7 +33,7 @@ public static unsafe Result CreateShaderModule(this Reflect thisApi, nuint s } /// To be documented. - [NativeName("Src", "Line 636, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 656, Column 18 in spirv_reflect.h")] public static unsafe Result CreateShaderModule(this Reflect thisApi, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_code, Span p_module) where T0 : unmanaged { // SpanOverloader @@ -41,7 +41,7 @@ public static unsafe Result CreateShaderModule(this Reflect thisApi, nuint s } /// To be documented. - [NativeName("Src", "Line 651, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 671, Column 18 in spirv_reflect.h")] public static unsafe Result CreateShaderModule2(this Reflect thisApi, uint flags, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* p_code, Span p_module) { // SpanOverloader @@ -49,7 +49,7 @@ public static unsafe Result CreateShaderModule2(this Reflect thisApi, uint flags } /// To be documented. - [NativeName("Src", "Line 651, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 671, Column 18 in spirv_reflect.h")] public static unsafe Result CreateShaderModule2(this Reflect thisApi, uint flags, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_code, ReflectShaderModule* p_module) where T0 : unmanaged { // SpanOverloader @@ -57,7 +57,7 @@ public static unsafe Result CreateShaderModule2(this Reflect thisApi, uint f } /// To be documented. - [NativeName("Src", "Line 651, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 671, Column 18 in spirv_reflect.h")] public static unsafe Result CreateShaderModule2(this Reflect thisApi, uint flags, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_code, Span p_module) where T0 : unmanaged { // SpanOverloader @@ -65,7 +65,7 @@ public static unsafe Result CreateShaderModule2(this Reflect thisApi, uint f } /// To be documented. - [NativeName("Src", "Line 659, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 679, Column 18 in spirv_reflect.h")] public static unsafe Result GetShaderModule(this Reflect thisApi, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* p_code, Span p_module) { // SpanOverloader @@ -73,7 +73,7 @@ public static unsafe Result GetShaderModule(this Reflect thisApi, nuint size, [F } /// To be documented. - [NativeName("Src", "Line 659, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 679, Column 18 in spirv_reflect.h")] public static unsafe Result GetShaderModule(this Reflect thisApi, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_code, ReflectShaderModule* p_module) where T0 : unmanaged { // SpanOverloader @@ -81,7 +81,7 @@ public static unsafe Result GetShaderModule(this Reflect thisApi, nuint size } /// To be documented. - [NativeName("Src", "Line 659, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 679, Column 18 in spirv_reflect.h")] public static unsafe Result GetShaderModule(this Reflect thisApi, nuint size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_code, Span p_module) where T0 : unmanaged { // SpanOverloader @@ -89,7 +89,7 @@ public static unsafe Result GetShaderModule(this Reflect thisApi, nuint size } /// To be documented. - [NativeName("Src", "Line 671, Column 6 in spirv_reflect.h")] + [NativeName("Src", "Line 691, Column 6 in spirv_reflect.h")] public static unsafe void DestroyShaderModule(this Reflect thisApi, Span p_module) { // SpanOverloader @@ -97,7 +97,7 @@ public static unsafe void DestroyShaderModule(this Reflect thisApi, SpanTo be documented. - [NativeName("Src", "Line 680, Column 10 in spirv_reflect.h")] + [NativeName("Src", "Line 700, Column 10 in spirv_reflect.h")] public static unsafe uint GetCodeSize(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module) { // SpanOverloader @@ -105,7 +105,7 @@ public static unsafe uint GetCodeSize(this Reflect thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 689, Column 17 in spirv_reflect.h")] + [NativeName("Src", "Line 709, Column 17 in spirv_reflect.h")] public static unsafe uint* GetCode(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module) { // SpanOverloader @@ -113,7 +113,7 @@ public static unsafe uint GetCodeSize(this Reflect thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 698, Column 29 in spirv_reflect.h")] + [NativeName("Src", "Line 718, Column 29 in spirv_reflect.h")] public static unsafe EntryPoint* GetEntryPoint(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point) { // SpanOverloader @@ -121,7 +121,7 @@ public static unsafe uint GetCodeSize(this Reflect thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 698, Column 29 in spirv_reflect.h")] + [NativeName("Src", "Line 718, Column 29 in spirv_reflect.h")] public static unsafe EntryPoint* GetEntryPoint(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point) { // SpanOverloader @@ -129,7 +129,7 @@ public static unsafe uint GetCodeSize(this Reflect thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 698, Column 29 in spirv_reflect.h")] + [NativeName("Src", "Line 718, Column 29 in spirv_reflect.h")] public static unsafe EntryPoint* GetEntryPoint(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point) { // SpanOverloader @@ -137,7 +137,7 @@ public static unsafe uint GetCodeSize(this Reflect thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 698, Column 29 in spirv_reflect.h")] + [NativeName("Src", "Line 718, Column 29 in spirv_reflect.h")] public static unsafe EntryPoint* GetEntryPoint(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point) { // SpanOverloader @@ -145,7 +145,7 @@ public static unsafe uint GetCodeSize(this Reflect thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -153,7 +153,7 @@ public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -161,7 +161,7 @@ public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -169,7 +169,7 @@ public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -177,7 +177,7 @@ public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -185,7 +185,7 @@ public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 721, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 741, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -193,7 +193,7 @@ public static unsafe Result EnumerateDescriptorBindings(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -201,7 +201,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -209,7 +209,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -217,7 +217,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -225,7 +225,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -233,7 +233,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -241,7 +241,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -249,7 +249,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -257,7 +257,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -265,7 +265,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -273,7 +273,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -281,7 +281,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -289,7 +289,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -297,7 +297,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -305,7 +305,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -313,7 +313,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -321,7 +321,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -329,7 +329,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -337,7 +337,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, DescriptorBinding** pp_bindings) { // SpanOverloader @@ -345,7 +345,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 747, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 767, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref DescriptorBinding* pp_bindings) { // SpanOverloader @@ -353,7 +353,7 @@ public static unsafe Result EnumerateEntryPointDescriptorBindings(this Reflect t } /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -361,7 +361,7 @@ public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -369,7 +369,7 @@ public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -377,7 +377,7 @@ public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -385,7 +385,7 @@ public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -393,7 +393,7 @@ public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 772, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 792, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -401,7 +401,7 @@ public static unsafe Result EnumerateDescriptorSets(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -409,7 +409,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -417,7 +417,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -425,7 +425,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -433,7 +433,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -441,7 +441,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -449,7 +449,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -457,7 +457,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -465,7 +465,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -473,7 +473,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -481,7 +481,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -489,7 +489,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -497,7 +497,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -505,7 +505,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -513,7 +513,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -521,7 +521,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -529,7 +529,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -537,7 +537,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -545,7 +545,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ReflectDescriptorSet** pp_sets) { // SpanOverloader @@ -553,7 +553,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 798, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 818, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref ReflectDescriptorSet* pp_sets) { // SpanOverloader @@ -561,7 +561,7 @@ public static unsafe Result EnumerateEntryPointDescriptorSets(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -569,7 +569,7 @@ public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -577,7 +577,7 @@ public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -585,7 +585,7 @@ public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -593,7 +593,7 @@ public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -601,7 +601,7 @@ public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 825, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 845, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -609,7 +609,7 @@ public static unsafe Result EnumerateInterfaceVariables(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -617,7 +617,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -625,7 +625,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -633,7 +633,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -641,7 +641,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -649,7 +649,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -657,7 +657,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -665,7 +665,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -673,7 +673,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -681,7 +681,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -689,7 +689,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -697,7 +697,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -705,7 +705,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -713,7 +713,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -721,7 +721,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -729,7 +729,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -737,7 +737,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -745,7 +745,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -753,7 +753,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -761,7 +761,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 850, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 870, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -769,7 +769,7 @@ public static unsafe Result EnumerateEntryPointInterfaceVariables(this Reflect t } /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -777,7 +777,7 @@ public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -785,7 +785,7 @@ public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -793,7 +793,7 @@ public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -801,7 +801,7 @@ public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -809,7 +809,7 @@ public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 877, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 897, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -817,7 +817,7 @@ public static unsafe Result EnumerateInputVariables(this Reflect thisApi, [Flow( } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -825,7 +825,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -833,7 +833,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -841,7 +841,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -849,7 +849,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -857,7 +857,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -865,7 +865,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -873,7 +873,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -881,7 +881,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -889,7 +889,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -897,7 +897,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -905,7 +905,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -913,7 +913,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -921,7 +921,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -929,7 +929,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -937,7 +937,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -945,7 +945,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -953,7 +953,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -961,7 +961,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -969,7 +969,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 902, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 922, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -977,7 +977,7 @@ public static unsafe Result EnumerateEntryPointInputVariables(this Reflect thisA } /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -985,7 +985,7 @@ public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow } /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -993,7 +993,7 @@ public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow } /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1001,7 +1001,7 @@ public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow } /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1009,7 +1009,7 @@ public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow } /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1017,7 +1017,7 @@ public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow } /// To be documented. - [NativeName("Src", "Line 929, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 949, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1025,7 +1025,7 @@ public static unsafe Result EnumerateOutputVariables(this Reflect thisApi, [Flow } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1033,7 +1033,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1041,7 +1041,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1049,7 +1049,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1057,7 +1057,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1065,7 +1065,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1073,7 +1073,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1081,7 +1081,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1089,7 +1089,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1097,7 +1097,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1105,7 +1105,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1113,7 +1113,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1121,7 +1121,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1129,7 +1129,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1137,7 +1137,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1145,7 +1145,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1153,7 +1153,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1161,7 +1161,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1169,7 +1169,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, InterfaceVariable** pp_variables) { // SpanOverloader @@ -1177,7 +1177,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 954, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 974, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref InterfaceVariable* pp_variables) { // SpanOverloader @@ -1185,7 +1185,7 @@ public static unsafe Result EnumerateEntryPointOutputVariables(this Reflect this } /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1193,7 +1193,7 @@ public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1201,7 +1201,7 @@ public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1209,7 +1209,7 @@ public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1217,7 +1217,7 @@ public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1225,7 +1225,7 @@ public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 982, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1002, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1233,7 +1233,7 @@ public static unsafe Result EnumeratePushConstantBlocks(this Reflect thisApi, [F } /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1241,7 +1241,7 @@ public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(S } /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1249,7 +1249,7 @@ public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(S } /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1257,7 +1257,7 @@ public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(S } /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1265,7 +1265,7 @@ public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(S } /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1273,7 +1273,7 @@ public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(S } /// To be documented. - [NativeName("Src", "Line 988, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1008, Column 18 in spirv_reflect.h")] public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1281,7 +1281,7 @@ public static unsafe Result EnumeratePushConstants(this Reflect thisApi, [Flow(S } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1289,7 +1289,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1297,7 +1297,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1305,7 +1305,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1313,7 +1313,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1321,7 +1321,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1329,7 +1329,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1337,7 +1337,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1345,7 +1345,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1353,7 +1353,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint* p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1361,7 +1361,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1369,7 +1369,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1377,7 +1377,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1385,7 +1385,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint* p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1393,7 +1393,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1401,7 +1401,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1409,7 +1409,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1417,7 +1417,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint* p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1425,7 +1425,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, BlockVariable** pp_blocks) { // SpanOverloader @@ -1433,7 +1433,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1014, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1034, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_count, ref BlockVariable* pp_blocks) { // SpanOverloader @@ -1441,7 +1441,7 @@ public static unsafe Result EnumerateEntryPointPushConstantBlocks(this Reflect t } /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateSpecializationConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, SpecializationConstant** pp_constants) { // SpanOverloader @@ -1449,7 +1449,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateSpecializationConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, Span p_count, ref SpecializationConstant* pp_constants) { // SpanOverloader @@ -1457,7 +1457,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateSpecializationConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, SpecializationConstant** pp_constants) { // SpanOverloader @@ -1465,7 +1465,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateSpecializationConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint* p_count, ref SpecializationConstant* pp_constants) { // SpanOverloader @@ -1473,7 +1473,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateSpecializationConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, SpecializationConstant** pp_constants) { // SpanOverloader @@ -1481,7 +1481,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1035, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1055, Column 18 in spirv_reflect.h")] public static unsafe Result EnumerateSpecializationConstants(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, Span p_count, ref SpecializationConstant* pp_constants) { // SpanOverloader @@ -1489,7 +1489,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1063, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1083, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint binding_number, uint set_number, Span p_result) { // SpanOverloader @@ -1497,7 +1497,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1063, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1083, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint binding_number, uint set_number, Result* p_result) { // SpanOverloader @@ -1505,7 +1505,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1063, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1083, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint binding_number, uint set_number, Span p_result) { // SpanOverloader @@ -1513,7 +1513,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetEntryPointDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint binding_number, uint set_number, Span p_result) { // SpanOverloader @@ -1521,7 +1521,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetEntryPointDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint binding_number, uint set_number, Result* p_result) { // SpanOverloader @@ -1529,7 +1529,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetEntryPointDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint binding_number, uint set_number, Span p_result) { // SpanOverloader @@ -1537,7 +1537,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetEntryPointDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint binding_number, uint set_number, Span p_result) { // SpanOverloader @@ -1545,7 +1545,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetEntryPointDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint binding_number, uint set_number, Result* p_result) { // SpanOverloader @@ -1553,7 +1553,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetEntryPointDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint binding_number, uint set_number, Span p_result) { // SpanOverloader @@ -1561,7 +1561,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetEntryPointDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint binding_number, uint set_number, Result* p_result) { // SpanOverloader @@ -1569,7 +1569,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetEntryPointDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint binding_number, uint set_number, Span p_result) { // SpanOverloader @@ -1577,7 +1577,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetEntryPointDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint binding_number, uint set_number, Result* p_result) { // SpanOverloader @@ -1585,7 +1585,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1095, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1115, Column 36 in spirv_reflect.h")] public static unsafe DescriptorBinding* GetEntryPointDescriptorBinding(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint binding_number, uint set_number, Span p_result) { // SpanOverloader @@ -1593,7 +1593,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1120, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1140, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint set_number, Span p_result) { // SpanOverloader @@ -1601,7 +1601,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1120, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1140, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint set_number, Result* p_result) { // SpanOverloader @@ -1609,7 +1609,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1120, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1140, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint set_number, Span p_result) { // SpanOverloader @@ -1617,7 +1617,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetEntryPointDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint set_number, Span p_result) { // SpanOverloader @@ -1625,7 +1625,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetEntryPointDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint set_number, Result* p_result) { // SpanOverloader @@ -1633,7 +1633,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetEntryPointDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint set_number, Span p_result) { // SpanOverloader @@ -1641,7 +1641,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetEntryPointDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint set_number, Span p_result) { // SpanOverloader @@ -1649,7 +1649,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetEntryPointDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint set_number, Result* p_result) { // SpanOverloader @@ -1657,7 +1657,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetEntryPointDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint set_number, Span p_result) { // SpanOverloader @@ -1665,7 +1665,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetEntryPointDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint set_number, Result* p_result) { // SpanOverloader @@ -1673,7 +1673,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetEntryPointDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint set_number, Span p_result) { // SpanOverloader @@ -1681,7 +1681,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetEntryPointDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint set_number, Result* p_result) { // SpanOverloader @@ -1689,7 +1689,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1143, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1163, Column 32 in spirv_reflect.h")] public static unsafe ReflectDescriptorSet* GetEntryPointDescriptorSet(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint set_number, Span p_result) { // SpanOverloader @@ -1697,7 +1697,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1171, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1191, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, Span p_result) { // SpanOverloader @@ -1705,7 +1705,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1171, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1191, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint location, Result* p_result) { // SpanOverloader @@ -1713,7 +1713,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1171, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1191, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint location, Span p_result) { // SpanOverloader @@ -1721,7 +1721,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1177, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1197, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariable(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, Span p_result) { // SpanOverloader @@ -1729,7 +1729,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1177, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1197, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariable(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint location, Result* p_result) { // SpanOverloader @@ -1737,7 +1737,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1177, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1197, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariable(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint location, Span p_result) { // SpanOverloader @@ -1745,7 +1745,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, Span p_result) { // SpanOverloader @@ -1753,7 +1753,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint location, Result* p_result) { // SpanOverloader @@ -1761,7 +1761,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint location, Span p_result) { // SpanOverloader @@ -1769,7 +1769,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, Span p_result) { // SpanOverloader @@ -1777,7 +1777,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, Result* p_result) { // SpanOverloader @@ -1785,7 +1785,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, Span p_result) { // SpanOverloader @@ -1793,7 +1793,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint location, Result* p_result) { // SpanOverloader @@ -1801,7 +1801,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint location, Span p_result) { // SpanOverloader @@ -1809,7 +1809,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, Result* p_result) { // SpanOverloader @@ -1817,7 +1817,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1204, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1224, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, Span p_result) { // SpanOverloader @@ -1825,7 +1825,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -1833,7 +1833,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -1841,7 +1841,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -1849,7 +1849,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -1857,7 +1857,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result) { // SpanOverloader @@ -1865,7 +1865,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -1873,7 +1873,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -1881,7 +1881,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -1889,7 +1889,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result) { // SpanOverloader @@ -1897,7 +1897,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1232, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1252, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -1905,7 +1905,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -1913,7 +1913,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -1921,7 +1921,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -1929,7 +1929,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -1937,7 +1937,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result) { // SpanOverloader @@ -1945,7 +1945,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -1953,7 +1953,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -1961,7 +1961,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -1969,7 +1969,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result) { // SpanOverloader @@ -1977,7 +1977,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -1985,7 +1985,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -1993,7 +1993,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2001,7 +2001,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2009,7 +2009,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2017,7 +2017,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result) { // SpanOverloader @@ -2025,7 +2025,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -2033,7 +2033,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2041,7 +2041,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2049,7 +2049,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result) { // SpanOverloader @@ -2057,7 +2057,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2065,7 +2065,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result) { // SpanOverloader @@ -2073,7 +2073,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -2081,7 +2081,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2089,7 +2089,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2097,7 +2097,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result) { // SpanOverloader @@ -2105,7 +2105,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2113,7 +2113,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result) { // SpanOverloader @@ -2121,7 +2121,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -2129,7 +2129,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2137,7 +2137,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2145,7 +2145,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result) { // SpanOverloader @@ -2153,7 +2153,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1260, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1280, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointInputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2161,7 +2161,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1287, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1307, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, Span p_result) { // SpanOverloader @@ -2169,7 +2169,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1287, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1307, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint location, Result* p_result) { // SpanOverloader @@ -2177,7 +2177,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1287, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1307, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint location, Span p_result) { // SpanOverloader @@ -2185,7 +2185,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1293, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1313, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariable(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint location, Span p_result) { // SpanOverloader @@ -2193,7 +2193,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1293, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1313, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariable(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint location, Result* p_result) { // SpanOverloader @@ -2201,7 +2201,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1293, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1313, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariable(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint location, Span p_result) { // SpanOverloader @@ -2209,7 +2209,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, Span p_result) { // SpanOverloader @@ -2217,7 +2217,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint location, Result* p_result) { // SpanOverloader @@ -2225,7 +2225,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint location, Span p_result) { // SpanOverloader @@ -2233,7 +2233,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, Span p_result) { // SpanOverloader @@ -2241,7 +2241,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, Result* p_result) { // SpanOverloader @@ -2249,7 +2249,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, uint location, Span p_result) { // SpanOverloader @@ -2257,7 +2257,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint location, Result* p_result) { // SpanOverloader @@ -2265,7 +2265,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, uint location, Span p_result) { // SpanOverloader @@ -2273,7 +2273,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, Result* p_result) { // SpanOverloader @@ -2281,7 +2281,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1320, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1340, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableByLocation(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, uint location, Span p_result) { // SpanOverloader @@ -2289,7 +2289,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -2297,7 +2297,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2305,7 +2305,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2313,7 +2313,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2321,7 +2321,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result) { // SpanOverloader @@ -2329,7 +2329,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -2337,7 +2337,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2345,7 +2345,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2353,7 +2353,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result) { // SpanOverloader @@ -2361,7 +2361,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1348, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1368, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2369,7 +2369,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -2377,7 +2377,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2385,7 +2385,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2393,7 +2393,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2401,7 +2401,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result) { // SpanOverloader @@ -2409,7 +2409,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -2417,7 +2417,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2425,7 +2425,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2433,7 +2433,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result) { // SpanOverloader @@ -2441,7 +2441,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2449,7 +2449,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -2457,7 +2457,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2465,7 +2465,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2473,7 +2473,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2481,7 +2481,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result) { // SpanOverloader @@ -2489,7 +2489,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -2497,7 +2497,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2505,7 +2505,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2513,7 +2513,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result) { // SpanOverloader @@ -2521,7 +2521,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2529,7 +2529,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result) { // SpanOverloader @@ -2537,7 +2537,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -2545,7 +2545,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2553,7 +2553,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2561,7 +2561,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result) { // SpanOverloader @@ -2569,7 +2569,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2577,7 +2577,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Result* p_result) { // SpanOverloader @@ -2585,7 +2585,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* semantic, Span p_result) { // SpanOverloader @@ -2593,7 +2593,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Result* p_result) { // SpanOverloader @@ -2601,7 +2601,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan semantic, Span p_result) { // SpanOverloader @@ -2609,7 +2609,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Result* p_result) { // SpanOverloader @@ -2617,7 +2617,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1376, Column 36 in spirv_reflect.h")] + [NativeName("Src", "Line 1396, Column 36 in spirv_reflect.h")] public static unsafe InterfaceVariable* GetEntryPointOutputVariableBySemantic(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string semantic, Span p_result) { // SpanOverloader @@ -2625,7 +2625,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1400, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1420, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint index, Span p_result) { // SpanOverloader @@ -2633,7 +2633,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1400, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1420, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint index, Result* p_result) { // SpanOverloader @@ -2641,7 +2641,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1400, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1420, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint index, Span p_result) { // SpanOverloader @@ -2649,7 +2649,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1406, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1426, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetPushConstant(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, uint index, Span p_result) { // SpanOverloader @@ -2657,7 +2657,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1406, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1426, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetPushConstant(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint index, Result* p_result) { // SpanOverloader @@ -2665,7 +2665,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1406, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1426, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetPushConstant(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, uint index, Span p_result) { // SpanOverloader @@ -2673,7 +2673,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetEntryPointPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_result) { // SpanOverloader @@ -2681,7 +2681,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetEntryPointPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Result* p_result) { // SpanOverloader @@ -2689,7 +2689,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetEntryPointPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_result) { // SpanOverloader @@ -2697,7 +2697,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetEntryPointPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_result) { // SpanOverloader @@ -2705,7 +2705,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetEntryPointPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Result* p_result) { // SpanOverloader @@ -2713,7 +2713,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetEntryPointPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* entry_point, Span p_result) { // SpanOverloader @@ -2721,7 +2721,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetEntryPointPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Result* p_result) { // SpanOverloader @@ -2729,7 +2729,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetEntryPointPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan entry_point, Span p_result) { // SpanOverloader @@ -2737,7 +2737,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetEntryPointPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Result* p_result) { // SpanOverloader @@ -2745,7 +2745,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1431, Column 32 in spirv_reflect.h")] + [NativeName("Src", "Line 1451, Column 32 in spirv_reflect.h")] public static unsafe BlockVariable* GetEntryPointPushConstantBlock(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string entry_point, Span p_result) { // SpanOverloader @@ -2753,7 +2753,7 @@ public static unsafe Result EnumerateSpecializationConstants(this Reflect thisAp } /// To be documented. - [NativeName("Src", "Line 1461, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1481, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeDescriptorBindingNumbers(this Reflect thisApi, ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_binding, uint new_binding_number, uint new_set_number) { // SpanOverloader @@ -2761,7 +2761,7 @@ public static unsafe Result ChangeDescriptorBindingNumbers(this Reflect thisApi, } /// To be documented. - [NativeName("Src", "Line 1461, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1481, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeDescriptorBindingNumbers(this Reflect thisApi, Span p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DescriptorBinding* p_binding, uint new_binding_number, uint new_set_number) { // SpanOverloader @@ -2769,7 +2769,7 @@ public static unsafe Result ChangeDescriptorBindingNumbers(this Reflect thisApi, } /// To be documented. - [NativeName("Src", "Line 1461, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1481, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeDescriptorBindingNumbers(this Reflect thisApi, Span p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_binding, uint new_binding_number, uint new_set_number) { // SpanOverloader @@ -2777,7 +2777,7 @@ public static unsafe Result ChangeDescriptorBindingNumbers(this Reflect thisApi, } /// To be documented. - [NativeName("Src", "Line 1468, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1488, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeDescriptorBindingNumber(this Reflect thisApi, ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_descriptor_binding, uint new_binding_number, uint optional_new_set_number) { // SpanOverloader @@ -2785,7 +2785,7 @@ public static unsafe Result ChangeDescriptorBindingNumber(this Reflect thisApi, } /// To be documented. - [NativeName("Src", "Line 1468, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1488, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeDescriptorBindingNumber(this Reflect thisApi, Span p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DescriptorBinding* p_descriptor_binding, uint new_binding_number, uint optional_new_set_number) { // SpanOverloader @@ -2793,7 +2793,7 @@ public static unsafe Result ChangeDescriptorBindingNumber(this Reflect thisApi, } /// To be documented. - [NativeName("Src", "Line 1468, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1488, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeDescriptorBindingNumber(this Reflect thisApi, Span p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_descriptor_binding, uint new_binding_number, uint optional_new_set_number) { // SpanOverloader @@ -2801,7 +2801,7 @@ public static unsafe Result ChangeDescriptorBindingNumber(this Reflect thisApi, } /// To be documented. - [NativeName("Src", "Line 1497, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1517, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeDescriptorSetNumber(this Reflect thisApi, ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_set, uint new_set_number) { // SpanOverloader @@ -2809,7 +2809,7 @@ public static unsafe Result ChangeDescriptorSetNumber(this Reflect thisApi, Refl } /// To be documented. - [NativeName("Src", "Line 1497, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1517, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeDescriptorSetNumber(this Reflect thisApi, Span p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReflectDescriptorSet* p_set, uint new_set_number) { // SpanOverloader @@ -2817,7 +2817,7 @@ public static unsafe Result ChangeDescriptorSetNumber(this Reflect thisApi, Span } /// To be documented. - [NativeName("Src", "Line 1497, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1517, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeDescriptorSetNumber(this Reflect thisApi, Span p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_set, uint new_set_number) { // SpanOverloader @@ -2825,7 +2825,7 @@ public static unsafe Result ChangeDescriptorSetNumber(this Reflect thisApi, Span } /// To be documented. - [NativeName("Src", "Line 1520, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1540, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeInputVariableLocation(this Reflect thisApi, ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_input_variable, uint new_location) { // SpanOverloader @@ -2833,7 +2833,7 @@ public static unsafe Result ChangeInputVariableLocation(this Reflect thisApi, Re } /// To be documented. - [NativeName("Src", "Line 1520, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1540, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeInputVariableLocation(this Reflect thisApi, Span p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] InterfaceVariable* p_input_variable, uint new_location) { // SpanOverloader @@ -2841,7 +2841,7 @@ public static unsafe Result ChangeInputVariableLocation(this Reflect thisApi, Sp } /// To be documented. - [NativeName("Src", "Line 1520, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1540, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeInputVariableLocation(this Reflect thisApi, Span p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_input_variable, uint new_location) { // SpanOverloader @@ -2849,7 +2849,7 @@ public static unsafe Result ChangeInputVariableLocation(this Reflect thisApi, Sp } /// To be documented. - [NativeName("Src", "Line 1544, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1564, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeOutputVariableLocation(this Reflect thisApi, ReflectShaderModule* p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_output_variable, uint new_location) { // SpanOverloader @@ -2857,7 +2857,7 @@ public static unsafe Result ChangeOutputVariableLocation(this Reflect thisApi, R } /// To be documented. - [NativeName("Src", "Line 1544, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1564, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeOutputVariableLocation(this Reflect thisApi, Span p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] InterfaceVariable* p_output_variable, uint new_location) { // SpanOverloader @@ -2865,7 +2865,7 @@ public static unsafe Result ChangeOutputVariableLocation(this Reflect thisApi, S } /// To be documented. - [NativeName("Src", "Line 1544, Column 18 in spirv_reflect.h")] + [NativeName("Src", "Line 1564, Column 18 in spirv_reflect.h")] public static unsafe Result ChangeOutputVariableLocation(this Reflect thisApi, Span p_module, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_output_variable, uint new_location) { // SpanOverloader @@ -2873,7 +2873,7 @@ public static unsafe Result ChangeOutputVariableLocation(this Reflect thisApi, S } /// To be documented. - [NativeName("Src", "Line 1565, Column 13 in spirv_reflect.h")] + [NativeName("Src", "Line 1585, Column 13 in spirv_reflect.h")] public static unsafe byte* BlockVariableTypeName(this Reflect thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan p_var) { // SpanOverloader diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/BlockVariable.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/BlockVariable.gen.cs index 6b2d182ddb..aed2f58f0a 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/BlockVariable.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/BlockVariable.gen.cs @@ -174,8 +174,8 @@ public BlockVariable [NativeName("Name", "type_description")] public TypeDescription* TypeDescription; - [NativeName("Type", "struct (unnamed struct at spirv_reflect.h:473:3)")] - [NativeName("Type.Name", "struct (unnamed struct at spirv_reflect.h:473:3)")] + [NativeName("Type", "struct (unnamed struct at spirv_reflect.h:478:3)")] + [NativeName("Type.Name", "struct (unnamed struct at spirv_reflect.h:478:3)")] [NativeName("Name", "word_offset")] public BlockVariableWordOffset WordOffset; } diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/BlockVariableWordOffset.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/BlockVariableWordOffset.gen.cs index 161a7c1e25..f61db48c45 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/BlockVariableWordOffset.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/BlockVariableWordOffset.gen.cs @@ -16,7 +16,7 @@ namespace Silk.NET.SPIRV.Reflect { - [NativeName("Name", "__AnonymousRecord_spirv_reflect_L473_C3")] + [NativeName("Name", "__AnonymousRecord_spirv_reflect_L478_C3")] public unsafe partial struct BlockVariableWordOffset { public BlockVariableWordOffset diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/DescriptorBinding.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/DescriptorBinding.gen.cs index 7d1f137f01..589c58fb26 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/DescriptorBinding.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/DescriptorBinding.gen.cs @@ -230,8 +230,8 @@ public DescriptorBinding [NativeName("Name", "type_description")] public TypeDescription* TypeDescription; - [NativeName("Type", "struct (unnamed struct at spirv_reflect.h:502:3)")] - [NativeName("Type.Name", "struct (unnamed struct at spirv_reflect.h:502:3)")] + [NativeName("Type", "struct (unnamed struct at spirv_reflect.h:507:3)")] + [NativeName("Type.Name", "struct (unnamed struct at spirv_reflect.h:507:3)")] [NativeName("Name", "word_offset")] public DescriptorBindingWordOffset WordOffset; diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/DescriptorBindingWordOffset.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/DescriptorBindingWordOffset.gen.cs index ac1e2c787d..98928c48ba 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/DescriptorBindingWordOffset.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/DescriptorBindingWordOffset.gen.cs @@ -16,7 +16,7 @@ namespace Silk.NET.SPIRV.Reflect { - [NativeName("Name", "__AnonymousRecord_spirv_reflect_L502_C3")] + [NativeName("Name", "__AnonymousRecord_spirv_reflect_L507_C3")] public unsafe partial struct DescriptorBindingWordOffset { public DescriptorBindingWordOffset diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/InterfaceVariable.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/InterfaceVariable.gen.cs index b32e304c31..6d00388934 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/InterfaceVariable.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/InterfaceVariable.gen.cs @@ -28,7 +28,7 @@ public InterfaceVariable Silk.NET.SPIRV.StorageClass? storageClass = null, byte* semantic = null, uint? decorationFlags = null, - Silk.NET.SPIRV.BuiltIn? builtIn = null, + int? builtIn = null, NumericTraits? numeric = null, ArrayTraits? array = null, uint? memberCount = null, @@ -150,10 +150,10 @@ public InterfaceVariable [NativeName("Name", "decoration_flags")] public uint DecorationFlags; - [NativeName("Type", "SpvBuiltIn")] - [NativeName("Type.Name", "SpvBuiltIn")] + [NativeName("Type", "int")] + [NativeName("Type.Name", "int")] [NativeName("Name", "built_in")] - public Silk.NET.SPIRV.BuiltIn BuiltIn; + public int BuiltIn; [NativeName("Type", "SpvReflectNumericTraits")] [NativeName("Type.Name", "SpvReflectNumericTraits")] @@ -185,8 +185,8 @@ public InterfaceVariable [NativeName("Name", "type_description")] public TypeDescription* TypeDescription; - [NativeName("Type", "struct (unnamed struct at spirv_reflect.h:447:3)")] - [NativeName("Type.Name", "struct (unnamed struct at spirv_reflect.h:447:3)")] + [NativeName("Type", "struct (unnamed struct at spirv_reflect.h:452:3)")] + [NativeName("Type.Name", "struct (unnamed struct at spirv_reflect.h:452:3)")] [NativeName("Name", "word_offset")] public InterfaceVariableWordOffset WordOffset; } diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/InterfaceVariableWordOffset.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/InterfaceVariableWordOffset.gen.cs index b6f0114793..098e4ff2b6 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/InterfaceVariableWordOffset.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/InterfaceVariableWordOffset.gen.cs @@ -16,7 +16,7 @@ namespace Silk.NET.SPIRV.Reflect { - [NativeName("Name", "__AnonymousRecord_spirv_reflect_L447_C3")] + [NativeName("Name", "__AnonymousRecord_spirv_reflect_L452_C3")] public unsafe partial struct InterfaceVariableWordOffset { public InterfaceVariableWordOffset diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/SpecializationConstant.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/SpecializationConstant.gen.cs index e806b5cca1..ea64a2d469 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/SpecializationConstant.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/SpecializationConstant.gen.cs @@ -23,7 +23,10 @@ public SpecializationConstant ( uint? spirvId = null, uint? constantId = null, - byte* name = null + byte* name = null, + TypeDescription* typeDescription = null, + uint? defaultValueSize = null, + void* defaultValue = null ) : this() { if (spirvId is not null) @@ -40,6 +43,21 @@ public SpecializationConstant { Name = name; } + + if (typeDescription is not null) + { + TypeDescription = typeDescription; + } + + if (defaultValueSize is not null) + { + DefaultValueSize = defaultValueSize.Value; + } + + if (defaultValue is not null) + { + DefaultValue = defaultValue; + } } @@ -57,5 +75,20 @@ public SpecializationConstant [NativeName("Type.Name", "const char *")] [NativeName("Name", "name")] public byte* Name; + + [NativeName("Type", "SpvReflectTypeDescription *")] + [NativeName("Type.Name", "SpvReflectTypeDescription *")] + [NativeName("Name", "type_description")] + public TypeDescription* TypeDescription; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "default_value_size")] + public uint DefaultValueSize; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "default_value")] + public void* DefaultValue; } } diff --git a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/TypeDescription.gen.cs b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/TypeDescription.gen.cs index b90acc47ea..2267941376 100644 --- a/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/TypeDescription.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV.Reflect/Structs/TypeDescription.gen.cs @@ -25,7 +25,7 @@ public TypeDescription Silk.NET.SPIRV.Op? op = null, byte* typeName = null, byte* structMemberName = null, - Silk.NET.SPIRV.StorageClass? storageClass = null, + int? storageClass = null, uint? typeFlags = null, uint? decorationFlags = null, Traits? traits = null, @@ -117,10 +117,10 @@ public TypeDescription [NativeName("Name", "struct_member_name")] public byte* StructMemberName; - [NativeName("Type", "SpvStorageClass")] - [NativeName("Type.Name", "SpvStorageClass")] + [NativeName("Type", "int")] + [NativeName("Type.Name", "int")] [NativeName("Name", "storage_class")] - public Silk.NET.SPIRV.StorageClass StorageClass; + public int StorageClass; [NativeName("Type", "SpvReflectTypeFlags")] [NativeName("Type.Name", "SpvReflectTypeFlags")] diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/BuiltIn.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/BuiltIn.gen.cs index 95804836f0..fe6b6b96e4 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/BuiltIn.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/BuiltIn.gen.cs @@ -138,6 +138,12 @@ public enum BuiltIn : int ViewIndex = 0x1158, [NativeName("Name", "SpvBuiltInShadingRateKHR")] ShadingRateKhr = 0x115C, + [NativeName("Name", "SpvBuiltInTileOffsetQCOM")] + TileOffsetQCom = 0x118C, + [NativeName("Name", "SpvBuiltInTileDimensionQCOM")] + TileDimensionQCom = 0x118D, + [NativeName("Name", "SpvBuiltInTileApronSizeQCOM")] + TileApronSizeQCom = 0x118E, [NativeName("Name", "SpvBuiltInBaryCoordNoPerspAMD")] BaryCoordNoPerspAmd = 0x1380, [NativeName("Name", "SpvBuiltInBaryCoordNoPerspCentroidAMD")] @@ -154,8 +160,8 @@ public enum BuiltIn : int BaryCoordPullModelAmd = 0x1386, [NativeName("Name", "SpvBuiltInFragStencilRefEXT")] FragStencilRefExt = 0x1396, - [NativeName("Name", "SpvBuiltInCoalescedInputCountAMDX")] - CoalescedInputCountAmdx = 0x139D, + [NativeName("Name", "SpvBuiltInRemainingRecursionLevelsAMDX")] + RemainingRecursionLevelsAmdx = 0x139D, [NativeName("Name", "SpvBuiltInShaderIndexAMDX")] ShaderIndexAmdx = 0x13D1, [NativeName("Name", "SpvBuiltInViewportMaskNV")] @@ -274,6 +280,12 @@ public enum BuiltIn : int IncomingRayFlagsNV = 0x14E7, [NativeName("Name", "SpvBuiltInRayGeometryIndexKHR")] RayGeometryIndexKhr = 0x14E8, + [NativeName("Name", "SpvBuiltInHitIsSphereNV")] + HitIsSphereNV = 0x14EF, + [NativeName("Name", "SpvBuiltInHitIsLSSNV")] + HitIsLssnv = 0x14F0, + [NativeName("Name", "SpvBuiltInHitSpherePositionNV")] + HitSpherePositionNV = 0x14F1, [NativeName("Name", "SpvBuiltInWarpsPerSMNV")] WarpsPerSmnv = 0x14FE, [NativeName("Name", "SpvBuiltInSMCountNV")] @@ -282,10 +294,18 @@ public enum BuiltIn : int WarpIdnv = 0x1500, [NativeName("Name", "SpvBuiltInSMIDNV")] Smidnv = 0x1501, + [NativeName("Name", "SpvBuiltInHitLSSPositionsNV")] + HitLssPositionsNV = 0x1514, [NativeName("Name", "SpvBuiltInHitKindFrontFacingMicroTriangleNV")] HitKindFrontFacingMicroTriangleNV = 0x151D, [NativeName("Name", "SpvBuiltInHitKindBackFacingMicroTriangleNV")] HitKindBackFacingMicroTriangleNV = 0x151E, + [NativeName("Name", "SpvBuiltInHitSphereRadiusNV")] + HitSphereRadiusNV = 0x152C, + [NativeName("Name", "SpvBuiltInHitLSSRadiiNV")] + HitLssRadiiNV = 0x152D, + [NativeName("Name", "SpvBuiltInClusterIDNV")] + ClusterIdnv = 0x153C, [NativeName("Name", "SpvBuiltInCullMaskKHR")] CullMaskKhr = 0x1785, [NativeName("Name", "SpvBuiltInMax")] diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/Capability.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/Capability.gen.cs index 3f6dc81d54..f2d5b4da5f 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/Capability.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/Capability.gen.cs @@ -160,8 +160,20 @@ public enum Capability : int TileImageDepthReadAccessExt = 0x1047, [NativeName("Name", "SpvCapabilityTileImageStencilReadAccessEXT")] TileImageStencilReadAccessExt = 0x1048, + [NativeName("Name", "SpvCapabilityTensorsARM")] + TensorsArm = 0x104E, + [NativeName("Name", "SpvCapabilityStorageTensorArrayDynamicIndexingARM")] + StorageTensorArrayDynamicIndexingArm = 0x104F, + [NativeName("Name", "SpvCapabilityStorageTensorArrayNonUniformIndexingARM")] + StorageTensorArrayNonUniformIndexingArm = 0x1050, + [NativeName("Name", "SpvCapabilityGraphARM")] + GraphArm = 0x105F, [NativeName("Name", "SpvCapabilityCooperativeMatrixLayoutsARM")] CooperativeMatrixLayoutsArm = 0x1069, + [NativeName("Name", "SpvCapabilityFloat8EXT")] + Float8Ext = 0x1074, + [NativeName("Name", "SpvCapabilityFloat8CooperativeMatrixEXT")] + Float8CooperativeMatrixExt = 0x1075, [NativeName("Name", "SpvCapabilityFragmentShadingRateKHR")] FragmentShadingRateKhr = 0x1146, [NativeName("Name", "SpvCapabilitySubgroupBallotKHR")] @@ -232,6 +244,8 @@ public enum Capability : int TextureBoxFilterQCom = 0x1185, [NativeName("Name", "SpvCapabilityTextureBlockMatchQCOM")] TextureBlockMatchQCom = 0x1186, + [NativeName("Name", "SpvCapabilityTileShadingQCOM")] + TileShadingQCom = 0x118F, [NativeName("Name", "SpvCapabilityTextureBlockMatch2QCOM")] TextureBlockMatch2QCom = 0x1192, [NativeName("Name", "SpvCapabilityFloat16ImageAMD")] @@ -252,6 +266,16 @@ public enum Capability : int ShaderEnqueueAmdx = 0x13CB, [NativeName("Name", "SpvCapabilityQuadControlKHR")] QuadControlKhr = 0x13DF, + [NativeName("Name", "SpvCapabilityInt4TypeINTEL")] + Int4TypeIntel = 0x13F8, + [NativeName("Name", "SpvCapabilityInt4CooperativeMatrixINTEL")] + Int4CooperativeMatrixIntel = 0x13FA, + [NativeName("Name", "SpvCapabilityBFloat16TypeKHR")] + BFloat16TypeKhr = 0x13FC, + [NativeName("Name", "SpvCapabilityBFloat16DotProductKHR")] + BFloat16DotProductKhr = 0x13FD, + [NativeName("Name", "SpvCapabilityBFloat16CooperativeMatrixKHR")] + BFloat16CooperativeMatrixKhr = 0x13FE, [NativeName("Name", "SpvCapabilitySampleMaskOverrideCoverageNV")] SampleMaskOverrideCoverageNV = 0x1481, [NativeName("Name", "SpvCapabilityGeometryShaderPassthroughNV")] @@ -384,12 +408,34 @@ public enum Capability : int BindlessTextureNV = 0x150E, [NativeName("Name", "SpvCapabilityRayQueryPositionFetchKHR")] RayQueryPositionFetchKhr = 0x150F, + [NativeName("Name", "SpvCapabilityCooperativeVectorNV")] + CooperativeVectorNV = 0x1512, [NativeName("Name", "SpvCapabilityAtomicFloat16VectorNV")] AtomicFloat16VectorNV = 0x151C, [NativeName("Name", "SpvCapabilityRayTracingDisplacementMicromapNV")] RayTracingDisplacementMicromapNV = 0x1521, [NativeName("Name", "SpvCapabilityRawAccessChainsNV")] RawAccessChainsNV = 0x1526, + [NativeName("Name", "SpvCapabilityRayTracingSpheresGeometryNV")] + RayTracingSpheresGeometryNV = 0x152A, + [NativeName("Name", "SpvCapabilityRayTracingLinearSweptSpheresGeometryNV")] + RayTracingLinearSweptSpheresGeometryNV = 0x152B, + [NativeName("Name", "SpvCapabilityCooperativeMatrixReductionsNV")] + CooperativeMatrixReductionsNV = 0x1536, + [NativeName("Name", "SpvCapabilityCooperativeMatrixConversionsNV")] + CooperativeMatrixConversionsNV = 0x1537, + [NativeName("Name", "SpvCapabilityCooperativeMatrixPerElementOperationsNV")] + CooperativeMatrixPerElementOperationsNV = 0x1538, + [NativeName("Name", "SpvCapabilityCooperativeMatrixTensorAddressingNV")] + CooperativeMatrixTensorAddressingNV = 0x1539, + [NativeName("Name", "SpvCapabilityCooperativeMatrixBlockLoadsNV")] + CooperativeMatrixBlockLoadsNV = 0x153A, + [NativeName("Name", "SpvCapabilityCooperativeVectorTrainingNV")] + CooperativeVectorTrainingNV = 0x153B, + [NativeName("Name", "SpvCapabilityRayTracingClusterAccelerationStructureNV")] + RayTracingClusterAccelerationStructureNV = 0x153D, + [NativeName("Name", "SpvCapabilityTensorAddressingNV")] + TensorAddressingNV = 0x153F, [NativeName("Name", "SpvCapabilitySubgroupShuffleINTEL")] SubgroupShuffleIntel = 0x15C0, [NativeName("Name", "SpvCapabilitySubgroupBufferBlockIOINTEL")] @@ -508,6 +554,8 @@ public enum Capability : int AtomicFloat64AddExt = 0x1792, [NativeName("Name", "SpvCapabilityLongCompositesINTEL")] LongCompositesIntel = 0x17C9, + [NativeName("Name", "SpvCapabilityOptNoneEXT")] + OptNoneExt = 0x17CE, [NativeName("Name", "SpvCapabilityOptNoneINTEL")] OptNoneIntel = 0x17CE, [NativeName("Name", "SpvCapabilityAtomicFloat16AddEXT")] @@ -518,10 +566,14 @@ public enum Capability : int BFloat16ConversionIntel = 0x17E3, [NativeName("Name", "SpvCapabilitySplitBarrierINTEL")] SplitBarrierIntel = 0x17FD, + [NativeName("Name", "SpvCapabilityArithmeticFenceEXT")] + ArithmeticFenceExt = 0x1800, [NativeName("Name", "SpvCapabilityFPGAClusterAttributesV2INTEL")] FpgaClusterAttributesV2intel = 0x1806, [NativeName("Name", "SpvCapabilityFPGAKernelAttributesv2INTEL")] FpgaKernelAttributesv2intel = 0x1811, + [NativeName("Name", "SpvCapabilityTaskSequenceINTEL")] + TaskSequenceIntel = 0x1812, [NativeName("Name", "SpvCapabilityFPMaxErrorINTEL")] FPMaxErrorIntel = 0x1819, [NativeName("Name", "SpvCapabilityFPGALatencyControlINTEL")] @@ -534,14 +586,28 @@ public enum Capability : int GlobalVariableFpgaDecorationsIntel = 0x182D, [NativeName("Name", "SpvCapabilitySubgroupBufferPrefetchINTEL")] SubgroupBufferPrefetchIntel = 0x184C, + [NativeName("Name", "SpvCapabilitySubgroup2DBlockIOINTEL")] + Subgroup2DBlockIointel = 0x1854, + [NativeName("Name", "SpvCapabilitySubgroup2DBlockTransformINTEL")] + Subgroup2DBlockTransformIntel = 0x1855, + [NativeName("Name", "SpvCapabilitySubgroup2DBlockTransposeINTEL")] + Subgroup2DBlockTransposeIntel = 0x1856, + [NativeName("Name", "SpvCapabilitySubgroupMatrixMultiplyAccumulateINTEL")] + SubgroupMatrixMultiplyAccumulateIntel = 0x185C, + [NativeName("Name", "SpvCapabilityTernaryBitwiseFunctionINTEL")] + TernaryBitwiseFunctionIntel = 0x1861, [NativeName("Name", "SpvCapabilityGroupUniformArithmeticKHR")] GroupUniformArithmeticKhr = 0x1900, + [NativeName("Name", "SpvCapabilityTensorFloat32RoundingINTEL")] + TensorFloat32RoundingIntel = 0x1919, [NativeName("Name", "SpvCapabilityMaskedGatherScatterINTEL")] MaskedGatherScatterIntel = 0x191B, [NativeName("Name", "SpvCapabilityCacheControlsINTEL")] CacheControlsIntel = 0x1929, [NativeName("Name", "SpvCapabilityRegisterLimitsINTEL")] RegisterLimitsIntel = 0x193C, + [NativeName("Name", "SpvCapabilityBindlessImagesINTEL")] + BindlessImagesIntel = 0x1980, [NativeName("Name", "SpvCapabilityMax")] Max = 0x7FFFFFFF, } diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/ComponentType.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/ComponentType.gen.cs new file mode 100644 index 0000000000..810b589892 --- /dev/null +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/ComponentType.gen.cs @@ -0,0 +1,48 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SPIRV +{ + [NativeName("Name", "SpvComponentType_")] + public enum ComponentType : int + { + [NativeName("Name", "SpvComponentTypeFloat16NV")] + Float16NV = 0x0, + [NativeName("Name", "SpvComponentTypeFloat32NV")] + Float32NV = 0x1, + [NativeName("Name", "SpvComponentTypeFloat64NV")] + Float64NV = 0x2, + [NativeName("Name", "SpvComponentTypeSignedInt8NV")] + SignedInt8NV = 0x3, + [NativeName("Name", "SpvComponentTypeSignedInt16NV")] + SignedInt16NV = 0x4, + [NativeName("Name", "SpvComponentTypeSignedInt32NV")] + SignedInt32NV = 0x5, + [NativeName("Name", "SpvComponentTypeSignedInt64NV")] + SignedInt64NV = 0x6, + [NativeName("Name", "SpvComponentTypeUnsignedInt8NV")] + UnsignedInt8NV = 0x7, + [NativeName("Name", "SpvComponentTypeUnsignedInt16NV")] + UnsignedInt16NV = 0x8, + [NativeName("Name", "SpvComponentTypeUnsignedInt32NV")] + UnsignedInt32NV = 0x9, + [NativeName("Name", "SpvComponentTypeUnsignedInt64NV")] + UnsignedInt64NV = 0xA, + [NativeName("Name", "SpvComponentTypeSignedInt8PackedNV")] + SignedInt8PackedNV = 0x3BA247F8, + [NativeName("Name", "SpvComponentTypeUnsignedInt8PackedNV")] + UnsignedInt8PackedNV = 0x3BA247F9, + [NativeName("Name", "SpvComponentTypeFloatE4M3NV")] + FloatE4M3NV = 0x3BA247FA, + [NativeName("Name", "SpvComponentTypeFloatE5M2NV")] + FloatE5M2NV = 0x3BA247FB, + [NativeName("Name", "SpvComponentTypeMax")] + Max = 0x7FFFFFFF, + } +} diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeMatrixReduceMask.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeMatrixReduceMask.gen.cs new file mode 100644 index 0000000000..05c1b41677 --- /dev/null +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeMatrixReduceMask.gen.cs @@ -0,0 +1,25 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SPIRV +{ + [Flags] + [NativeName("Name", "SpvCooperativeMatrixReduceMask_")] + public enum CooperativeMatrixReduceMask : int + { + [NativeName("Name", "SpvCooperativeMatrixReduceMaskNone")] + MaskNone = 0x0, + [NativeName("Name", "SpvCooperativeMatrixReduceRowMask")] + RowMask = 0x1, + [NativeName("Name", "SpvCooperativeMatrixReduceColumnMask")] + ColumnMask = 0x2, + [NativeName("Name", "SpvCooperativeMatrixReduce2x2Mask")] + X2Mask = 0x4, + } +} diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeMatrixReduceShift.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeMatrixReduceShift.gen.cs new file mode 100644 index 0000000000..0924b8adbc --- /dev/null +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeMatrixReduceShift.gen.cs @@ -0,0 +1,24 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SPIRV +{ + [NativeName("Name", "SpvCooperativeMatrixReduceShift_")] + public enum CooperativeMatrixReduceShift : int + { + [NativeName("Name", "SpvCooperativeMatrixReduceRowShift")] + RowShift = 0x0, + [NativeName("Name", "SpvCooperativeMatrixReduceColumnShift")] + ColumnShift = 0x1, + [NativeName("Name", "SpvCooperativeMatrixReduce2x2Shift")] + X2Shift = 0x2, + [NativeName("Name", "SpvCooperativeMatrixReduceMax")] + Max = 0x7FFFFFFF, + } +} diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeVectorMatrixLayout.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeVectorMatrixLayout.gen.cs new file mode 100644 index 0000000000..c32b6bdb95 --- /dev/null +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/CooperativeVectorMatrixLayout.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SPIRV +{ + [NativeName("Name", "SpvCooperativeVectorMatrixLayout_")] + public enum CooperativeVectorMatrixLayout : int + { + [NativeName("Name", "SpvCooperativeVectorMatrixLayoutRowMajorNV")] + RowMajorNV = 0x0, + [NativeName("Name", "SpvCooperativeVectorMatrixLayoutColumnMajorNV")] + ColumnMajorNV = 0x1, + [NativeName("Name", "SpvCooperativeVectorMatrixLayoutInferencingOptimalNV")] + InferencingOptimalNV = 0x2, + [NativeName("Name", "SpvCooperativeVectorMatrixLayoutTrainingOptimalNV")] + TrainingOptimalNV = 0x3, + [NativeName("Name", "SpvCooperativeVectorMatrixLayoutMax")] + Max = 0x7FFFFFFF, + } +} diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/Decoration.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/Decoration.gen.cs index aa87ecbacf..2ae71a98c8 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/Decoration.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/Decoration.gen.cs @@ -106,6 +106,8 @@ public enum Decoration : int AlignmentId = 0x2E, [NativeName("Name", "SpvDecorationMaxByteOffsetId")] MaxByteOffsetId = 0x2F, + [NativeName("Name", "SpvDecorationSaturatedToLargestFloat8NormalConversionEXT")] + SaturatedToLargestFloat8NormalConversionExt = 0x1078, [NativeName("Name", "SpvDecorationNoSignedWrap")] NoSignedWrap = 0x1175, [NativeName("Name", "SpvDecorationNoUnsignedWrap")] @@ -126,6 +128,14 @@ public enum Decoration : int TrackFinishWritingAmdx = 0x13D6, [NativeName("Name", "SpvDecorationPayloadNodeNameAMDX")] PayloadNodeNameAmdx = 0x13E3, + [NativeName("Name", "SpvDecorationPayloadNodeBaseIndexAMDX")] + PayloadNodeBaseIndexAmdx = 0x13EA, + [NativeName("Name", "SpvDecorationPayloadNodeSparseArrayAMDX")] + PayloadNodeSparseArrayAmdx = 0x13EB, + [NativeName("Name", "SpvDecorationPayloadNodeArraySizeAMDX")] + PayloadNodeArraySizeAmdx = 0x13EC, + [NativeName("Name", "SpvDecorationPayloadDispatchIndirectAMDX")] + PayloadDispatchIndirectAmdx = 0x13F1, [NativeName("Name", "SpvDecorationOverrideCoverageNV")] OverrideCoverageNV = 0x1480, [NativeName("Name", "SpvDecorationPassthroughNV")] diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/ExecutionMode.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/ExecutionMode.gen.cs index 9650d05be5..333968fbde 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/ExecutionMode.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/ExecutionMode.gen.cs @@ -108,12 +108,18 @@ public enum ExecutionMode : int RoundingModeRte = 0x116E, [NativeName("Name", "SpvExecutionModeRoundingModeRTZ")] RoundingModeRtz = 0x116F, + [NativeName("Name", "SpvExecutionModeNonCoherentTileAttachmentReadQCOM")] + NonCoherentTileAttachmentReadQCom = 0x1189, + [NativeName("Name", "SpvExecutionModeTileShadingRateQCOM")] + TileShadingRateQCom = 0x118A, [NativeName("Name", "SpvExecutionModeEarlyAndLateFragmentTestsAMD")] EarlyAndLateFragmentTestsAmd = 0x1399, [NativeName("Name", "SpvExecutionModeStencilRefReplacingEXT")] StencilRefReplacingExt = 0x13A3, [NativeName("Name", "SpvExecutionModeCoalescingAMDX")] CoalescingAmdx = 0x13CD, + [NativeName("Name", "SpvExecutionModeIsApiEntryAMDX")] + IsApiEntryAmdx = 0x13CE, [NativeName("Name", "SpvExecutionModeMaxNodeRecursionAMDX")] MaxNodeRecursionAmdx = 0x13CF, [NativeName("Name", "SpvExecutionModeStaticNumWorkgroupsAMDX")] @@ -138,6 +144,8 @@ public enum ExecutionMode : int QuadDerivativesKhr = 0x13E0, [NativeName("Name", "SpvExecutionModeRequireFullQuadsKHR")] RequireFullQuadsKhr = 0x13E1, + [NativeName("Name", "SpvExecutionModeSharesInputWithAMDX")] + SharesInputWithAmdx = 0x13EE, [NativeName("Name", "SpvExecutionModeOutputLinesEXT")] OutputLinesExt = 0x1495, [NativeName("Name", "SpvExecutionModeOutputLinesNV")] diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/FPEncoding.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/FPEncoding.gen.cs index 2f8d7c0ee3..04f9baa8a0 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/FPEncoding.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/FPEncoding.gen.cs @@ -12,6 +12,12 @@ namespace Silk.NET.SPIRV [NativeName("Name", "SpvFPEncoding_")] public enum FPEncoding : int { + [NativeName("Name", "SpvFPEncodingBFloat16KHR")] + BFloat16Khr = 0x0, + [NativeName("Name", "SpvFPEncodingFloat8E4M3EXT")] + Float8E4M3Ext = 0x1076, + [NativeName("Name", "SpvFPEncodingFloat8E5M2EXT")] + Float8E5M2Ext = 0x1077, [NativeName("Name", "SpvFPEncodingMax")] Max = 0x7FFFFFFF, } diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/FunctionControlMask.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/FunctionControlMask.gen.cs index 45f372e542..368345cc9e 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/FunctionControlMask.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/FunctionControlMask.gen.cs @@ -23,6 +23,8 @@ public enum FunctionControlMask : int PureMask = 0x4, [NativeName("Name", "SpvFunctionControlConstMask")] ConstMask = 0x8, + [NativeName("Name", "SpvFunctionControlOptNoneEXTMask")] + OptNoneExtMask = 0x10000, [NativeName("Name", "SpvFunctionControlOptNoneINTELMask")] OptNoneIntelMask = 0x10000, } diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/FunctionControlShift.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/FunctionControlShift.gen.cs index acb51ef3c3..05e6cfa227 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/FunctionControlShift.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/FunctionControlShift.gen.cs @@ -21,6 +21,8 @@ public enum FunctionControlShift : int PureShift = 0x2, [NativeName("Name", "SpvFunctionControlConstShift")] ConstShift = 0x3, + [NativeName("Name", "SpvFunctionControlOptNoneEXTShift")] + OptNoneExtShift = 0x10, [NativeName("Name", "SpvFunctionControlOptNoneINTELShift")] OptNoneIntelShift = 0x10, [NativeName("Name", "SpvFunctionControlMax")] diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/ImageChannelDataType.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/ImageChannelDataType.gen.cs index 00e8c625e4..fc416f8038 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/ImageChannelDataType.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/ImageChannelDataType.gen.cs @@ -46,12 +46,24 @@ public enum ImageChannelDataType : int UnormInt24 = 0xF, [NativeName("Name", "SpvImageChannelDataTypeUnormInt101010_2")] UnormInt1010102 = 0x10, + [NativeName("Name", "SpvImageChannelDataTypeUnormInt10X6EXT")] + UnormInt10X6Ext = 0x11, [NativeName("Name", "SpvImageChannelDataTypeUnsignedIntRaw10EXT")] UnsignedIntRaw10Ext = 0x13, [NativeName("Name", "SpvImageChannelDataTypeUnsignedIntRaw12EXT")] UnsignedIntRaw12Ext = 0x14, [NativeName("Name", "SpvImageChannelDataTypeUnormInt2_101010EXT")] UnormInt2101010Ext = 0x15, + [NativeName("Name", "SpvImageChannelDataTypeUnsignedInt10X6EXT")] + UnsignedInt10X6Ext = 0x16, + [NativeName("Name", "SpvImageChannelDataTypeUnsignedInt12X4EXT")] + UnsignedInt12X4Ext = 0x17, + [NativeName("Name", "SpvImageChannelDataTypeUnsignedInt14X2EXT")] + UnsignedInt14X2Ext = 0x18, + [NativeName("Name", "SpvImageChannelDataTypeUnormInt12X4EXT")] + UnormInt12X4Ext = 0x19, + [NativeName("Name", "SpvImageChannelDataTypeUnormInt14X2EXT")] + UnormInt14X2Ext = 0x1A, [NativeName("Name", "SpvImageChannelDataTypeMax")] Max = 0x7FFFFFFF, } diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/MatrixMultiplyAccumulateOperandsMask.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/MatrixMultiplyAccumulateOperandsMask.gen.cs new file mode 100644 index 0000000000..da5df0306e --- /dev/null +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/MatrixMultiplyAccumulateOperandsMask.gen.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SPIRV +{ + [Flags] + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMask_")] + public enum MatrixMultiplyAccumulateOperandsMask : int + { + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMaskNone")] + MaskNone = 0x0, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixASignedComponentsINTELMask")] + MatrixASignedComponentsIntelMask = 0x1, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBSignedComponentsINTELMask")] + MatrixBSignedComponentsIntelMask = 0x2, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixCBFloat16INTELMask")] + MatrixCBFloat16intelMask = 0x4, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixResultBFloat16INTELMask")] + MatrixResultBFloat16intelMask = 0x8, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixAPackedInt8INTELMask")] + MatrixAPackedInt8intelMask = 0x10, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBPackedInt8INTELMask")] + MatrixBPackedInt8intelMask = 0x20, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixAPackedInt4INTELMask")] + MatrixAPackedInt4intelMask = 0x40, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBPackedInt4INTELMask")] + MatrixBPackedInt4intelMask = 0x80, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixATF32INTELMask")] + MatrixAtf32intelMask = 0x100, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBTF32INTELMask")] + MatrixBtf32intelMask = 0x200, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixAPackedFloat16INTELMask")] + MatrixAPackedFloat16intelMask = 0x400, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBPackedFloat16INTELMask")] + MatrixBPackedFloat16intelMask = 0x800, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixAPackedBFloat16INTELMask")] + MatrixAPackedBFloat16intelMask = 0x1000, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBPackedBFloat16INTELMask")] + MatrixBPackedBFloat16intelMask = 0x2000, + } +} diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/MatrixMultiplyAccumulateOperandsShift.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/MatrixMultiplyAccumulateOperandsShift.gen.cs new file mode 100644 index 0000000000..af9faeaf28 --- /dev/null +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/MatrixMultiplyAccumulateOperandsShift.gen.cs @@ -0,0 +1,46 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SPIRV +{ + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsShift_")] + public enum MatrixMultiplyAccumulateOperandsShift : int + { + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixASignedComponentsINTELShift")] + MatrixASignedComponentsIntelShift = 0x0, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBSignedComponentsINTELShift")] + MatrixBSignedComponentsIntelShift = 0x1, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixCBFloat16INTELShift")] + MatrixCBFloat16intelShift = 0x2, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixResultBFloat16INTELShift")] + MatrixResultBFloat16intelShift = 0x3, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixAPackedInt8INTELShift")] + MatrixAPackedInt8intelShift = 0x4, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBPackedInt8INTELShift")] + MatrixBPackedInt8intelShift = 0x5, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixAPackedInt4INTELShift")] + MatrixAPackedInt4intelShift = 0x6, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBPackedInt4INTELShift")] + MatrixBPackedInt4intelShift = 0x7, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixATF32INTELShift")] + MatrixAtf32intelShift = 0x8, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBTF32INTELShift")] + MatrixBtf32intelShift = 0x9, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixAPackedFloat16INTELShift")] + MatrixAPackedFloat16intelShift = 0xA, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBPackedFloat16INTELShift")] + MatrixBPackedFloat16intelShift = 0xB, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixAPackedBFloat16INTELShift")] + MatrixAPackedBFloat16intelShift = 0xC, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMatrixBPackedBFloat16INTELShift")] + MatrixBPackedBFloat16intelShift = 0xD, + [NativeName("Name", "SpvMatrixMultiplyAccumulateOperandsMax")] + Max = 0x7FFFFFFF, + } +} diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/Op.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/Op.gen.cs index 1b4270b727..99120be9c8 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/Op.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/Op.gen.cs @@ -706,6 +706,28 @@ public enum Op : int DepthAttachmentReadExt = 0x1041, [NativeName("Name", "SpvOpStencilAttachmentReadEXT")] StencilAttachmentReadExt = 0x1042, + [NativeName("Name", "SpvOpTypeTensorARM")] + TypeTensorArm = 0x1043, + [NativeName("Name", "SpvOpTensorReadARM")] + TensorReadArm = 0x1044, + [NativeName("Name", "SpvOpTensorWriteARM")] + TensorWriteArm = 0x1045, + [NativeName("Name", "SpvOpTensorQuerySizeARM")] + TensorQuerySizeArm = 0x1046, + [NativeName("Name", "SpvOpGraphConstantARM")] + GraphConstantArm = 0x1055, + [NativeName("Name", "SpvOpGraphEntryPointARM")] + GraphEntryPointArm = 0x1056, + [NativeName("Name", "SpvOpGraphARM")] + GraphArm = 0x1057, + [NativeName("Name", "SpvOpGraphInputARM")] + GraphInputArm = 0x1058, + [NativeName("Name", "SpvOpGraphSetOutputARM")] + GraphSetOutputArm = 0x1059, + [NativeName("Name", "SpvOpGraphEndARM")] + GraphEndArm = 0x105A, + [NativeName("Name", "SpvOpTypeGraphARM")] + TypeGraphArm = 0x105E, [NativeName("Name", "SpvOpTerminateInvocation")] TerminateInvocation = 0x1140, [NativeName("Name", "SpvOpTypeUntypedPointerKHR")] @@ -842,12 +864,22 @@ public enum Op : int FragmentFetchAmd = 0x1394, [NativeName("Name", "SpvOpReadClockKHR")] ReadClockKhr = 0x13C0, - [NativeName("Name", "SpvOpFinalizeNodePayloadsAMDX")] - FinalizeNodePayloadsAmdx = 0x13D3, + [NativeName("Name", "SpvOpAllocateNodePayloadsAMDX")] + AllocateNodePayloadsAmdx = 0x13D2, + [NativeName("Name", "SpvOpEnqueueNodePayloadsAMDX")] + EnqueueNodePayloadsAmdx = 0x13D3, + [NativeName("Name", "SpvOpTypeNodePayloadArrayAMDX")] + TypeNodePayloadArrayAmdx = 0x13D4, [NativeName("Name", "SpvOpFinishWritingNodePayloadAMDX")] FinishWritingNodePayloadAmdx = 0x13D6, - [NativeName("Name", "SpvOpInitializeNodePayloadsAMDX")] - InitializeNodePayloadsAmdx = 0x13E2, + [NativeName("Name", "SpvOpNodePayloadArrayLengthAMDX")] + NodePayloadArrayLengthAmdx = 0x13E2, + [NativeName("Name", "SpvOpIsNodePayloadValidAMDX")] + IsNodePayloadValidAmdx = 0x13ED, + [NativeName("Name", "SpvOpConstantStringAMDX")] + ConstantStringAmdx = 0x13EF, + [NativeName("Name", "SpvOpSpecConstantStringAMDX")] + SpecConstantStringAmdx = 0x13F0, [NativeName("Name", "SpvOpGroupNonUniformQuadAllKHR")] GroupNonUniformQuadAllKhr = 0x13F6, [NativeName("Name", "SpvOpGroupNonUniformQuadAnyKHR")] @@ -920,6 +952,18 @@ public enum Op : int TypeHitObjectNV = 0x14A1, [NativeName("Name", "SpvOpImageSampleFootprintNV")] ImageSampleFootprintNV = 0x14A3, + [NativeName("Name", "SpvOpTypeCooperativeVectorNV")] + TypeCooperativeVectorNV = 0x14A8, + [NativeName("Name", "SpvOpCooperativeVectorMatrixMulNV")] + CooperativeVectorMatrixMulNV = 0x14A9, + [NativeName("Name", "SpvOpCooperativeVectorOuterProductAccumulateNV")] + CooperativeVectorOuterProductAccumulateNV = 0x14AA, + [NativeName("Name", "SpvOpCooperativeVectorReduceSumAccumulateNV")] + CooperativeVectorReduceSumAccumulateNV = 0x14AB, + [NativeName("Name", "SpvOpCooperativeVectorMatrixMulAddNV")] + CooperativeVectorMatrixMulAddNV = 0x14AC, + [NativeName("Name", "SpvOpCooperativeMatrixConvertNV")] + CooperativeMatrixConvertNV = 0x14AD, [NativeName("Name", "SpvOpEmitMeshTasksEXT")] EmitMeshTasksExt = 0x14AE, [NativeName("Name", "SpvOpSetMeshOutputsEXT")] @@ -932,6 +976,10 @@ public enum Op : int FetchMicroTriangleVertexPositionNV = 0x14B4, [NativeName("Name", "SpvOpFetchMicroTriangleVertexBarycentricNV")] FetchMicroTriangleVertexBarycentricNV = 0x14B5, + [NativeName("Name", "SpvOpCooperativeVectorLoadNV")] + CooperativeVectorLoadNV = 0x14B6, + [NativeName("Name", "SpvOpCooperativeVectorStoreNV")] + CooperativeVectorStoreNV = 0x14B7, [NativeName("Name", "SpvOpReportIntersectionKHR")] ReportIntersectionKhr = 0x14D6, [NativeName("Name", "SpvOpReportIntersectionNV")] @@ -954,6 +1002,10 @@ public enum Op : int TypeAccelerationStructureNV = 0x14DD, [NativeName("Name", "SpvOpExecuteCallableNV")] ExecuteCallableNV = 0x14E0, + [NativeName("Name", "SpvOpRayQueryGetClusterIdNV")] + RayQueryGetClusterIdNV = 0x14E1, + [NativeName("Name", "SpvOpHitObjectGetClusterIdNV")] + HitObjectGetClusterIdNV = 0x14E2, [NativeName("Name", "SpvOpTypeCooperativeMatrixNV")] TypeCooperativeMatrixNV = 0x14EE, [NativeName("Name", "SpvOpCooperativeMatrixLoadNV")] @@ -968,12 +1020,46 @@ public enum Op : int BeginInvocationInterlockExt = 0x14F4, [NativeName("Name", "SpvOpEndInvocationInterlockEXT")] EndInvocationInterlockExt = 0x14F5, + [NativeName("Name", "SpvOpCooperativeMatrixReduceNV")] + CooperativeMatrixReduceNV = 0x14F6, + [NativeName("Name", "SpvOpCooperativeMatrixLoadTensorNV")] + CooperativeMatrixLoadTensorNV = 0x14F7, + [NativeName("Name", "SpvOpCooperativeMatrixStoreTensorNV")] + CooperativeMatrixStoreTensorNV = 0x14F8, + [NativeName("Name", "SpvOpCooperativeMatrixPerElementOpNV")] + CooperativeMatrixPerElementOpNV = 0x14F9, + [NativeName("Name", "SpvOpTypeTensorLayoutNV")] + TypeTensorLayoutNV = 0x14FA, + [NativeName("Name", "SpvOpTypeTensorViewNV")] + TypeTensorViewNV = 0x14FB, + [NativeName("Name", "SpvOpCreateTensorLayoutNV")] + CreateTensorLayoutNV = 0x14FC, + [NativeName("Name", "SpvOpTensorLayoutSetDimensionNV")] + TensorLayoutSetDimensionNV = 0x14FD, + [NativeName("Name", "SpvOpTensorLayoutSetStrideNV")] + TensorLayoutSetStrideNV = 0x14FE, + [NativeName("Name", "SpvOpTensorLayoutSliceNV")] + TensorLayoutSliceNV = 0x14FF, + [NativeName("Name", "SpvOpTensorLayoutSetClampValueNV")] + TensorLayoutSetClampValueNV = 0x1500, + [NativeName("Name", "SpvOpCreateTensorViewNV")] + CreateTensorViewNV = 0x1501, + [NativeName("Name", "SpvOpTensorViewSetDimensionNV")] + TensorViewSetDimensionNV = 0x1502, + [NativeName("Name", "SpvOpTensorViewSetStrideNV")] + TensorViewSetStrideNV = 0x1503, [NativeName("Name", "SpvOpDemoteToHelperInvocation")] DemoteToHelperInvocation = 0x1504, [NativeName("Name", "SpvOpDemoteToHelperInvocationEXT")] DemoteToHelperInvocationExt = 0x1504, [NativeName("Name", "SpvOpIsHelperInvocationEXT")] IsHelperInvocationExt = 0x1505, + [NativeName("Name", "SpvOpTensorViewSetClipNV")] + TensorViewSetClipNV = 0x1506, + [NativeName("Name", "SpvOpTensorLayoutSetBlockSizeNV")] + TensorLayoutSetBlockSizeNV = 0x1508, + [NativeName("Name", "SpvOpCooperativeMatrixTransposeNV")] + CooperativeMatrixTransposeNV = 0x150E, [NativeName("Name", "SpvOpConvertUToImageNV")] ConvertUToImageNV = 0x150F, [NativeName("Name", "SpvOpConvertUToSamplerNV")] @@ -990,6 +1076,32 @@ public enum Op : int SamplerImageAddressingModeNV = 0x1515, [NativeName("Name", "SpvOpRawAccessChainNV")] RawAccessChainNV = 0x1516, + [NativeName("Name", "SpvOpRayQueryGetIntersectionSpherePositionNV")] + RayQueryGetIntersectionSpherePositionNV = 0x1533, + [NativeName("Name", "SpvOpRayQueryGetIntersectionSphereRadiusNV")] + RayQueryGetIntersectionSphereRadiusNV = 0x1534, + [NativeName("Name", "SpvOpRayQueryGetIntersectionLSSPositionsNV")] + RayQueryGetIntersectionLssPositionsNV = 0x1535, + [NativeName("Name", "SpvOpRayQueryGetIntersectionLSSRadiiNV")] + RayQueryGetIntersectionLssRadiiNV = 0x1536, + [NativeName("Name", "SpvOpRayQueryGetIntersectionLSSHitValueNV")] + RayQueryGetIntersectionLssHitValueNV = 0x1537, + [NativeName("Name", "SpvOpHitObjectGetSpherePositionNV")] + HitObjectGetSpherePositionNV = 0x1538, + [NativeName("Name", "SpvOpHitObjectGetSphereRadiusNV")] + HitObjectGetSphereRadiusNV = 0x1539, + [NativeName("Name", "SpvOpHitObjectGetLSSPositionsNV")] + HitObjectGetLssPositionsNV = 0x153A, + [NativeName("Name", "SpvOpHitObjectGetLSSRadiiNV")] + HitObjectGetLssRadiiNV = 0x153B, + [NativeName("Name", "SpvOpHitObjectIsSphereHitNV")] + HitObjectIsSphereHitNV = 0x153C, + [NativeName("Name", "SpvOpHitObjectIsLSSHitNV")] + HitObjectIsLssHitNV = 0x153D, + [NativeName("Name", "SpvOpRayQueryIsSphereHitNV")] + RayQueryIsSphereHitNV = 0x153E, + [NativeName("Name", "SpvOpRayQueryIsLSSHitNV")] + RayQueryIsLssHitNV = 0x153F, [NativeName("Name", "SpvOpSubgroupShuffleINTEL")] SubgroupShuffleIntel = 0x15C3, [NativeName("Name", "SpvOpSubgroupShuffleDownINTEL")] @@ -1482,8 +1594,34 @@ public enum Op : int ControlBarrierArriveIntel = 0x17FE, [NativeName("Name", "SpvOpControlBarrierWaitINTEL")] ControlBarrierWaitIntel = 0x17FF, + [NativeName("Name", "SpvOpArithmeticFenceEXT")] + ArithmeticFenceExt = 0x1801, + [NativeName("Name", "SpvOpTaskSequenceCreateINTEL")] + TaskSequenceCreateIntel = 0x1813, + [NativeName("Name", "SpvOpTaskSequenceAsyncINTEL")] + TaskSequenceAsyncIntel = 0x1814, + [NativeName("Name", "SpvOpTaskSequenceGetINTEL")] + TaskSequenceGetIntel = 0x1815, + [NativeName("Name", "SpvOpTaskSequenceReleaseINTEL")] + TaskSequenceReleaseIntel = 0x1816, + [NativeName("Name", "SpvOpTypeTaskSequenceINTEL")] + TypeTaskSequenceIntel = 0x1837, [NativeName("Name", "SpvOpSubgroupBlockPrefetchINTEL")] SubgroupBlockPrefetchIntel = 0x184D, + [NativeName("Name", "SpvOpSubgroup2DBlockLoadINTEL")] + Subgroup2DBlockLoadIntel = 0x1857, + [NativeName("Name", "SpvOpSubgroup2DBlockLoadTransformINTEL")] + Subgroup2DBlockLoadTransformIntel = 0x1858, + [NativeName("Name", "SpvOpSubgroup2DBlockLoadTransposeINTEL")] + Subgroup2DBlockLoadTransposeIntel = 0x1859, + [NativeName("Name", "SpvOpSubgroup2DBlockPrefetchINTEL")] + Subgroup2DBlockPrefetchIntel = 0x185A, + [NativeName("Name", "SpvOpSubgroup2DBlockStoreINTEL")] + Subgroup2DBlockStoreIntel = 0x185B, + [NativeName("Name", "SpvOpSubgroupMatrixMultiplyAccumulateINTEL")] + SubgroupMatrixMultiplyAccumulateIntel = 0x185D, + [NativeName("Name", "SpvOpBitwiseFunctionINTEL")] + BitwiseFunctionIntel = 0x1862, [NativeName("Name", "SpvOpGroupIMulKHR")] GroupIMulKhr = 0x1901, [NativeName("Name", "SpvOpGroupFMulKHR")] @@ -1500,10 +1638,18 @@ public enum Op : int GroupLogicalOrKhr = 0x1907, [NativeName("Name", "SpvOpGroupLogicalXorKHR")] GroupLogicalXorKhr = 0x1908, + [NativeName("Name", "SpvOpRoundFToTF32INTEL")] + RoundFToTF32intel = 0x191A, [NativeName("Name", "SpvOpMaskedGatherINTEL")] MaskedGatherIntel = 0x191C, [NativeName("Name", "SpvOpMaskedScatterINTEL")] MaskedScatterIntel = 0x191D, + [NativeName("Name", "SpvOpConvertHandleToImageINTEL")] + ConvertHandleToImageIntel = 0x1981, + [NativeName("Name", "SpvOpConvertHandleToSamplerINTEL")] + ConvertHandleToSamplerIntel = 0x1982, + [NativeName("Name", "SpvOpConvertHandleToSampledImageINTEL")] + ConvertHandleToSampledImageIntel = 0x1983, [NativeName("Name", "SpvOpMax")] Max = 0x7FFFFFFF, } diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/RayFlagsMask.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/RayFlagsMask.gen.cs index 6d3ba26d0e..aa3b6a362a 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/RayFlagsMask.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/RayFlagsMask.gen.cs @@ -31,6 +31,8 @@ public enum RayFlagsMask : int CullOpaqueKhrMask = 0x40, [NativeName("Name", "SpvRayFlagsCullNoOpaqueKHRMask")] CullNoOpaqueKhrMask = 0x80, + [NativeName("Name", "SpvRayFlagsSkipBuiltinPrimitivesNVMask")] + SkipBuiltinPrimitivesNVMask = 0x100, [NativeName("Name", "SpvRayFlagsSkipTrianglesKHRMask")] SkipTrianglesKhrMask = 0x100, [NativeName("Name", "SpvRayFlagsSkipAABBsKHRMask")] diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/RayFlagsShift.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/RayFlagsShift.gen.cs index 24ea16227a..c5831f71f5 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/RayFlagsShift.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/RayFlagsShift.gen.cs @@ -28,6 +28,8 @@ public enum RayFlagsShift : int CullOpaqueKhrShift = 0x6, [NativeName("Name", "SpvRayFlagsCullNoOpaqueKHRShift")] CullNoOpaqueKhrShift = 0x7, + [NativeName("Name", "SpvRayFlagsSkipBuiltinPrimitivesNVShift")] + SkipBuiltinPrimitivesNVShift = 0x8, [NativeName("Name", "SpvRayFlagsSkipTrianglesKHRShift")] SkipTrianglesKhrShift = 0x8, [NativeName("Name", "SpvRayFlagsSkipAABBsKHRShift")] diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/SourceLanguage.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/SourceLanguage.gen.cs index 74757d1c7c..b67e89408c 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/SourceLanguage.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/SourceLanguage.gen.cs @@ -38,6 +38,8 @@ public enum SourceLanguage : int Slang = 0xB, [NativeName("Name", "SpvSourceLanguageZig")] Zig = 0xC, + [NativeName("Name", "SpvSourceLanguageRust")] + Rust = 0xD, [NativeName("Name", "SpvSourceLanguageMax")] Max = 0x7FFFFFFF, } diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/StorageClass.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/StorageClass.gen.cs index 5fcc455d04..f4497da033 100644 --- a/src/SPIRV/Silk.NET.SPIRV/Enums/StorageClass.gen.cs +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/StorageClass.gen.cs @@ -40,10 +40,10 @@ public enum StorageClass : int StorageBuffer = 0xC, [NativeName("Name", "SpvStorageClassTileImageEXT")] TileImageExt = 0x104C, + [NativeName("Name", "SpvStorageClassTileAttachmentQCOM")] + TileAttachmentQCom = 0x118B, [NativeName("Name", "SpvStorageClassNodePayloadAMDX")] NodePayloadAmdx = 0x13CC, - [NativeName("Name", "SpvStorageClassNodeOutputPayloadAMDX")] - NodeOutputPayloadAmdx = 0x13D4, [NativeName("Name", "SpvStorageClassCallableDataKHR")] CallableDataKhr = 0x14D0, [NativeName("Name", "SpvStorageClassCallableDataNV")] diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/TensorAddressingOperandsMask.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/TensorAddressingOperandsMask.gen.cs new file mode 100644 index 0000000000..450e8b7282 --- /dev/null +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/TensorAddressingOperandsMask.gen.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SPIRV +{ + [NativeName("Name", "SpvTensorAddressingOperandsMask_")] + public enum TensorAddressingOperandsMask : int + { + [NativeName("Name", "SpvTensorAddressingOperandsMaskNone")] + MaskNone = 0x0, + [NativeName("Name", "SpvTensorAddressingOperandsTensorViewMask")] + TensorViewMask = 0x1, + [NativeName("Name", "SpvTensorAddressingOperandsDecodeFuncMask")] + DecodeFuncMask = 0x2, + } +} diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/TensorAddressingOperandsShift.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/TensorAddressingOperandsShift.gen.cs new file mode 100644 index 0000000000..aaf006f931 --- /dev/null +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/TensorAddressingOperandsShift.gen.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SPIRV +{ + [NativeName("Name", "SpvTensorAddressingOperandsShift_")] + public enum TensorAddressingOperandsShift : int + { + [NativeName("Name", "SpvTensorAddressingOperandsTensorViewShift")] + TensorViewShift = 0x0, + [NativeName("Name", "SpvTensorAddressingOperandsDecodeFuncShift")] + DecodeFuncShift = 0x1, + [NativeName("Name", "SpvTensorAddressingOperandsMax")] + Max = 0x7FFFFFFF, + } +} diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/TensorClampMode.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/TensorClampMode.gen.cs new file mode 100644 index 0000000000..4040f80f20 --- /dev/null +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/TensorClampMode.gen.cs @@ -0,0 +1,28 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SPIRV +{ + [NativeName("Name", "SpvTensorClampMode_")] + public enum TensorClampMode : int + { + [NativeName("Name", "SpvTensorClampModeUndefined")] + Undefined = 0x0, + [NativeName("Name", "SpvTensorClampModeConstant")] + Constant = 0x1, + [NativeName("Name", "SpvTensorClampModeClampToEdge")] + ClampToEdge = 0x2, + [NativeName("Name", "SpvTensorClampModeRepeat")] + Repeat = 0x3, + [NativeName("Name", "SpvTensorClampModeRepeatMirrored")] + RepeatMirrored = 0x4, + [NativeName("Name", "SpvTensorClampModeMax")] + Max = 0x7FFFFFFF, + } +} diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/TensorOperandsMask.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/TensorOperandsMask.gen.cs new file mode 100644 index 0000000000..5150599db8 --- /dev/null +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/TensorOperandsMask.gen.cs @@ -0,0 +1,29 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SPIRV +{ + [Flags] + [NativeName("Name", "SpvTensorOperandsMask_")] + public enum TensorOperandsMask : int + { + [NativeName("Name", "SpvTensorOperandsMaskNone")] + MaskNone = 0x0, + [NativeName("Name", "SpvTensorOperandsNontemporalARMMask")] + NontemporalArmMask = 0x1, + [NativeName("Name", "SpvTensorOperandsOutOfBoundsValueARMMask")] + OutOfBoundsValueArmMask = 0x2, + [NativeName("Name", "SpvTensorOperandsMakeElementAvailableARMMask")] + MakeElementAvailableArmMask = 0x4, + [NativeName("Name", "SpvTensorOperandsMakeElementVisibleARMMask")] + MakeElementVisibleArmMask = 0x8, + [NativeName("Name", "SpvTensorOperandsNonPrivateElementARMMask")] + NonPrivateElementArmMask = 0x10, + } +} diff --git a/src/SPIRV/Silk.NET.SPIRV/Enums/TensorOperandsShift.gen.cs b/src/SPIRV/Silk.NET.SPIRV/Enums/TensorOperandsShift.gen.cs new file mode 100644 index 0000000000..f33bd7bb24 --- /dev/null +++ b/src/SPIRV/Silk.NET.SPIRV/Enums/TensorOperandsShift.gen.cs @@ -0,0 +1,28 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SPIRV +{ + [NativeName("Name", "SpvTensorOperandsShift_")] + public enum TensorOperandsShift : int + { + [NativeName("Name", "SpvTensorOperandsNontemporalARMShift")] + NontemporalArmShift = 0x0, + [NativeName("Name", "SpvTensorOperandsOutOfBoundsValueARMShift")] + OutOfBoundsValueArmShift = 0x1, + [NativeName("Name", "SpvTensorOperandsMakeElementAvailableARMShift")] + MakeElementAvailableArmShift = 0x2, + [NativeName("Name", "SpvTensorOperandsMakeElementVisibleARMShift")] + MakeElementVisibleArmShift = 0x3, + [NativeName("Name", "SpvTensorOperandsNonPrivateElementARMShift")] + NonPrivateElementArmShift = 0x4, + [NativeName("Name", "SpvTensorOperandsMax")] + Max = 0x7FFFFFFF, + } +} diff --git a/src/SPIRV/Silk.NET.Shaderc/Enums/EnvVersion.gen.cs b/src/SPIRV/Silk.NET.Shaderc/Enums/EnvVersion.gen.cs index 47639f0b94..dbc899eb03 100644 --- a/src/SPIRV/Silk.NET.Shaderc/Enums/EnvVersion.gen.cs +++ b/src/SPIRV/Silk.NET.Shaderc/Enums/EnvVersion.gen.cs @@ -21,6 +21,8 @@ public enum EnvVersion : int Vulkan12 = 0x402000, [NativeName("Name", "shaderc_env_version_vulkan_1_3")] Vulkan13 = 0x403000, + [NativeName("Name", "shaderc_env_version_vulkan_1_4")] + Vulkan14 = 0x404000, [NativeName("Name", "shaderc_env_version_opengl_4_5")] Opengl45 = 0x1C2, [NativeName("Name", "shaderc_env_version_webgpu")] diff --git a/src/SPIRV/Silk.NET.Shaderc/Enums/SpirvVersion.gen.cs b/src/SPIRV/Silk.NET.Shaderc/Enums/SpirvVersion.gen.cs index 73368e65a9..5a16bc09df 100644 --- a/src/SPIRV/Silk.NET.Shaderc/Enums/SpirvVersion.gen.cs +++ b/src/SPIRV/Silk.NET.Shaderc/Enums/SpirvVersion.gen.cs @@ -9,7 +9,7 @@ namespace Silk.NET.Shaderc { - [NativeName("AnonymousName", "__AnonymousEnum_env_L53_C9")] + [NativeName("AnonymousName", "__AnonymousEnum_env_L54_C9")] [NativeName("Name", "shaderc_spirv_version")] public enum SpirvVersion : int { diff --git a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.OHOS/OhosNativeBuffer.gen.cs b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.OHOS/OhosNativeBuffer.gen.cs deleted file mode 100644 index d7c2c8e885..0000000000 --- a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.OHOS/OhosNativeBuffer.gen.cs +++ /dev/null @@ -1,71 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Runtime.InteropServices; -using System.Runtime.CompilerServices; -using System.Text; -using Silk.NET.Core; -using Silk.NET.Core.Native; -using Silk.NET.Core.Attributes; -using Silk.NET.Core.Contexts; -using Silk.NET.Core.Loader; -using Silk.NET.Vulkan; -using Extension = Silk.NET.Core.Attributes.ExtensionAttribute; - -#pragma warning disable 1591 - -namespace Silk.NET.Vulkan.Extensions.OHOS -{ - [Extension("VK_OHOS_native_buffer")] - public unsafe partial class OhosNativeBuffer : NativeExtension - { - public const string ExtensionName = "VK_OHOS_native_buffer"; - /// To be documented. - [NativeApi(EntryPoint = "vkAcquireImageOHOS", Convention = CallingConvention.Winapi)] - public partial Result AcquireImageOhos([Count(Count = 0)] Device device, [Count(Count = 0)] Image image, [Count(Count = 0)] int nativeFenceFd, [Count(Count = 0)] Semaphore semaphore, [Count(Count = 0)] Fence fence); - - /// To be documented. - [NativeApi(EntryPoint = "vkGetSwapchainGrallocUsageOHOS", Convention = CallingConvention.Winapi)] - public unsafe partial Result GetSwapchainGrallocUsageOhos([Count(Count = 0)] Device device, [Count(Count = 0)] Format format, [Count(Count = 0)] ImageUsageFlags imageUsage, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] ulong* grallocUsage); - - /// To be documented. - [NativeApi(EntryPoint = "vkGetSwapchainGrallocUsageOHOS", Convention = CallingConvention.Winapi)] - public partial Result GetSwapchainGrallocUsageOhos([Count(Count = 0)] Device device, [Count(Count = 0)] Format format, [Count(Count = 0)] ImageUsageFlags imageUsage, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out ulong grallocUsage); - - /// To be documented. - [NativeApi(EntryPoint = "vkQueueSignalReleaseImageOHOS", Convention = CallingConvention.Winapi)] - public unsafe partial Result QueueSignalReleaseImageOhos([Count(Count = 0)] Queue queue, [Count(Count = 0)] uint waitSemaphoreCount, [Count(Parameter = "waitSemaphoreCount"), Flow(Silk.NET.Core.Native.FlowDirection.In)] Semaphore* pWaitSemaphores, [Count(Count = 0)] Image image, [Count(Count = 0)] int* pNativeFenceFd); - - /// To be documented. - [NativeApi(EntryPoint = "vkQueueSignalReleaseImageOHOS", Convention = CallingConvention.Winapi)] - public unsafe partial Result QueueSignalReleaseImageOhos([Count(Count = 0)] Queue queue, [Count(Count = 0)] uint waitSemaphoreCount, [Count(Parameter = "waitSemaphoreCount"), Flow(Silk.NET.Core.Native.FlowDirection.In)] Semaphore* pWaitSemaphores, [Count(Count = 0)] Image image, [Count(Count = 0)] ref int pNativeFenceFd); - - /// To be documented. - [NativeApi(EntryPoint = "vkQueueSignalReleaseImageOHOS", Convention = CallingConvention.Winapi)] - public unsafe partial Result QueueSignalReleaseImageOhos([Count(Count = 0)] Queue queue, [Count(Count = 0)] uint waitSemaphoreCount, [Count(Parameter = "waitSemaphoreCount"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Semaphore pWaitSemaphores, [Count(Count = 0)] Image image, [Count(Count = 0)] int* pNativeFenceFd); - - /// To be documented. - [NativeApi(EntryPoint = "vkQueueSignalReleaseImageOHOS", Convention = CallingConvention.Winapi)] - public partial Result QueueSignalReleaseImageOhos([Count(Count = 0)] Queue queue, [Count(Count = 0)] uint waitSemaphoreCount, [Count(Parameter = "waitSemaphoreCount"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Semaphore pWaitSemaphores, [Count(Count = 0)] Image image, [Count(Count = 0)] ref int pNativeFenceFd); - - /// To be documented. - public unsafe Result QueueSignalReleaseImageOhos([Count(Count = 0)] Queue queue, [Count(Parameter = "waitSemaphoreCount"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pWaitSemaphores, [Count(Count = 0)] Image image, [Count(Count = 0)] int* pNativeFenceFd) - { - // ImplicitCountSpanOverloader - return QueueSignalReleaseImageOhos(queue, (uint) pWaitSemaphores.Length, in pWaitSemaphores.GetPinnableReference(), image, pNativeFenceFd); - } - - /// To be documented. - public unsafe Result QueueSignalReleaseImageOhos([Count(Count = 0)] Queue queue, [Count(Parameter = "waitSemaphoreCount"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pWaitSemaphores, [Count(Count = 0)] Image image, [Count(Count = 0)] ref int pNativeFenceFd) - { - // ImplicitCountSpanOverloader - return QueueSignalReleaseImageOhos(queue, (uint) pWaitSemaphores.Length, in pWaitSemaphores.GetPinnableReference(), image, ref pNativeFenceFd); - } - - public OhosNativeBuffer(INativeContext ctx) - : base(ctx) - { - } - } -} - diff --git a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.OHOS/OhosNativeBufferOverloads.gen.cs b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.OHOS/OhosNativeBufferOverloads.gen.cs deleted file mode 100644 index 5f80c66edd..0000000000 --- a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.OHOS/OhosNativeBufferOverloads.gen.cs +++ /dev/null @@ -1,49 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Runtime.InteropServices; -using System.Runtime.CompilerServices; -using System.Text; -using Silk.NET.Core; -using Silk.NET.Core.Native; -using Silk.NET.Core.Attributes; -using Silk.NET.Core.Contexts; -using Silk.NET.Core.Loader; - -#pragma warning disable 1591 - -namespace Silk.NET.Vulkan.Extensions.OHOS -{ - public static class OhosNativeBufferOverloads - { - /// To be documented. - public static unsafe Result GetSwapchainGrallocUsageOhos(this OhosNativeBuffer thisApi, [Count(Count = 0)] Device device, [Count(Count = 0)] Format format, [Count(Count = 0)] ImageUsageFlags imageUsage, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span grallocUsage) - { - // SpanOverloader - return thisApi.GetSwapchainGrallocUsageOhos(device, format, imageUsage, out grallocUsage.GetPinnableReference()); - } - - /// To be documented. - public static unsafe Result QueueSignalReleaseImageOhos(this OhosNativeBuffer thisApi, [Count(Count = 0)] Queue queue, [Count(Count = 0)] uint waitSemaphoreCount, [Count(Parameter = "waitSemaphoreCount"), Flow(Silk.NET.Core.Native.FlowDirection.In)] Semaphore* pWaitSemaphores, [Count(Count = 0)] Image image, [Count(Count = 0)] Span pNativeFenceFd) - { - // SpanOverloader - return thisApi.QueueSignalReleaseImageOhos(queue, waitSemaphoreCount, pWaitSemaphores, image, ref pNativeFenceFd.GetPinnableReference()); - } - - /// To be documented. - public static unsafe Result QueueSignalReleaseImageOhos(this OhosNativeBuffer thisApi, [Count(Count = 0)] Queue queue, [Count(Count = 0)] uint waitSemaphoreCount, [Count(Parameter = "waitSemaphoreCount"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pWaitSemaphores, [Count(Count = 0)] Image image, [Count(Count = 0)] int* pNativeFenceFd) - { - // SpanOverloader - return thisApi.QueueSignalReleaseImageOhos(queue, waitSemaphoreCount, in pWaitSemaphores.GetPinnableReference(), image, pNativeFenceFd); - } - - /// To be documented. - public static unsafe Result QueueSignalReleaseImageOhos(this OhosNativeBuffer thisApi, [Count(Count = 0)] Queue queue, [Count(Count = 0)] uint waitSemaphoreCount, [Count(Parameter = "waitSemaphoreCount"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pWaitSemaphores, [Count(Count = 0)] Image image, [Count(Count = 0)] Span pNativeFenceFd) - { - // SpanOverloader - return thisApi.QueueSignalReleaseImageOhos(queue, waitSemaphoreCount, in pWaitSemaphores.GetPinnableReference(), image, ref pNativeFenceFd.GetPinnableReference()); - } - - } -} - diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/Format.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/Format.gen.cs index 790ae9971d..ea5fb4e993 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/Format.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/Format.gen.cs @@ -494,6 +494,66 @@ public enum Format : int G16B16R162Plane422UnormKhr = 1000156032, [NativeName("Name", "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR")] G16B16R163Plane444UnormKhr = 1000156033, + [NativeName("Name", "VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT")] + Astc3x3x3UnormBlockExt = 1000288000, + [NativeName("Name", "VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT")] + Astc3x3x3SrgbBlockExt = 1000288001, + [NativeName("Name", "VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT")] + Astc3x3x3SfloatBlockExt = 1000288002, + [NativeName("Name", "VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT")] + Astc4x3x3UnormBlockExt = 1000288003, + [NativeName("Name", "VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT")] + Astc4x3x3SrgbBlockExt = 1000288004, + [NativeName("Name", "VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT")] + Astc4x3x3SfloatBlockExt = 1000288005, + [NativeName("Name", "VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT")] + Astc4x4x3UnormBlockExt = 1000288006, + [NativeName("Name", "VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT")] + Astc4x4x3SrgbBlockExt = 1000288007, + [NativeName("Name", "VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT")] + Astc4x4x3SfloatBlockExt = 1000288008, + [NativeName("Name", "VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT")] + Astc4x4x4UnormBlockExt = 1000288009, + [NativeName("Name", "VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT")] + Astc4x4x4SrgbBlockExt = 1000288010, + [NativeName("Name", "VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT")] + Astc4x4x4SfloatBlockExt = 1000288011, + [NativeName("Name", "VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT")] + Astc5x4x4UnormBlockExt = 1000288012, + [NativeName("Name", "VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT")] + Astc5x4x4SrgbBlockExt = 1000288013, + [NativeName("Name", "VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT")] + Astc5x4x4SfloatBlockExt = 1000288014, + [NativeName("Name", "VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT")] + Astc5x5x4UnormBlockExt = 1000288015, + [NativeName("Name", "VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT")] + Astc5x5x4SrgbBlockExt = 1000288016, + [NativeName("Name", "VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT")] + Astc5x5x4SfloatBlockExt = 1000288017, + [NativeName("Name", "VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT")] + Astc5x5x5UnormBlockExt = 1000288018, + [NativeName("Name", "VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT")] + Astc5x5x5SrgbBlockExt = 1000288019, + [NativeName("Name", "VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT")] + Astc5x5x5SfloatBlockExt = 1000288020, + [NativeName("Name", "VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT")] + Astc6x5x5UnormBlockExt = 1000288021, + [NativeName("Name", "VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT")] + Astc6x5x5SrgbBlockExt = 1000288022, + [NativeName("Name", "VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT")] + Astc6x5x5SfloatBlockExt = 1000288023, + [NativeName("Name", "VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT")] + Astc6x6x5UnormBlockExt = 1000288024, + [NativeName("Name", "VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT")] + Astc6x6x5SrgbBlockExt = 1000288025, + [NativeName("Name", "VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT")] + Astc6x6x5SfloatBlockExt = 1000288026, + [NativeName("Name", "VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT")] + Astc6x6x6UnormBlockExt = 1000288027, + [NativeName("Name", "VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT")] + Astc6x6x6SrgbBlockExt = 1000288028, + [NativeName("Name", "VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT")] + Astc6x6x6SfloatBlockExt = 1000288029, [NativeName("Name", "VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT")] G8B8R82Plane444UnormExt = 1000330000, [NativeName("Name", "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT")] diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs index dcab2fe68b..3f7e63d8f5 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs @@ -1176,6 +1176,8 @@ public enum StructureType : int PhysicalDeviceCustomBorderColorPropertiesExt = 1000287001, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT")] PhysicalDeviceCustomBorderColorFeaturesExt = 1000287002, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT")] + PhysicalDeviceTextureCompressionAstc3DFeaturesExt = 1000288000, [NativeName("Name", "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR")] PipelineLibraryCreateInfoKhr = 1000290000, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV")] @@ -2268,12 +2270,6 @@ public enum StructureType : int VideoDecodeAV1InlineSessionParametersInfoKhr = 1000586003, [NativeName("Name", "VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS")] SurfaceCreateInfoOhos = 1000685000, - [NativeName("Name", "VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS")] - NativeBufferOhos = 1000453001, - [NativeName("Name", "VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS")] - SwapchainImageCreateInfoOhos = 1000453002, - [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS")] - PhysicalDevicePresentationPropertiesOhos = 1000453003, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI")] PhysicalDeviceHdrVividFeaturesHuawei = 1000590000, [NativeName("Name", "VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI")] @@ -2356,6 +2352,10 @@ public enum StructureType : int RenderingEndInfoKhr = 1000619003, [NativeName("Name", "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR")] ResolveImageModeInfoKhr = 1000630004, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT")] + PhysicalDeviceShaderLongVectorFeaturesExt = 1000635000, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT")] + PhysicalDeviceShaderLongVectorPropertiesExt = 1000635001, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC")] PhysicalDevicePipelineCacheIncrementalModeFeaturesSec = 1000637000, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT")] diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderLongVectorFeaturesEXT.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderLongVectorFeaturesEXT.gen.cs new file mode 100644 index 0000000000..513440298b --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderLongVectorFeaturesEXT.gen.cs @@ -0,0 +1,74 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDeviceShaderLongVectorFeaturesEXT")] + public unsafe partial struct PhysicalDeviceShaderLongVectorFeaturesEXT : IExtendsChain, IExtendsChain, IExtendsChain + { + public PhysicalDeviceShaderLongVectorFeaturesEXT + ( + StructureType? sType = StructureType.PhysicalDeviceShaderLongVectorFeaturesExt, + void* pNext = null, + Bool32? longVector = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (longVector is not null) + { + LongVector = longVector.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "longVector")] + public Bool32 LongVector; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.PhysicalDeviceShaderLongVectorFeaturesExt; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderLongVectorPropertiesEXT.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderLongVectorPropertiesEXT.gen.cs new file mode 100644 index 0000000000..0b9a56b0fc --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderLongVectorPropertiesEXT.gen.cs @@ -0,0 +1,74 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDeviceShaderLongVectorPropertiesEXT")] + public unsafe partial struct PhysicalDeviceShaderLongVectorPropertiesEXT : IExtendsChain, IExtendsChain + { + public PhysicalDeviceShaderLongVectorPropertiesEXT + ( + StructureType? sType = StructureType.PhysicalDeviceShaderLongVectorPropertiesExt, + void* pNext = null, + uint? maxVectorComponents = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (maxVectorComponents is not null) + { + MaxVectorComponents = maxVectorComponents.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "maxVectorComponents")] + public uint MaxVectorComponents; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.PhysicalDeviceShaderLongVectorPropertiesExt; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceTextureCompressionASTC3DFeaturesEXT.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceTextureCompressionASTC3DFeaturesEXT.gen.cs new file mode 100644 index 0000000000..60f93cbd03 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceTextureCompressionASTC3DFeaturesEXT.gen.cs @@ -0,0 +1,74 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT")] + public unsafe partial struct PhysicalDeviceTextureCompressionASTC3DFeaturesEXT : IExtendsChain, IExtendsChain, IExtendsChain + { + public PhysicalDeviceTextureCompressionASTC3DFeaturesEXT + ( + StructureType? sType = StructureType.PhysicalDeviceTextureCompressionAstc3DFeaturesExt, + void* pNext = null, + Bool32? textureCompressionAstc3D = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (textureCompressionAstc3D is not null) + { + TextureCompressionAstc3D = textureCompressionAstc3D.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "textureCompressionASTC_3D")] + public Bool32 TextureCompressionAstc3D; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.PhysicalDeviceTextureCompressionAstc3DFeaturesExt; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Dawn.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Dawn.gen.cs index da84a4e607..e1c4342833 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Dawn.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Dawn.gen.cs @@ -45,6 +45,21 @@ public unsafe partial class Dawn : NativeExtension [NativeApi(EntryPoint = "wgpuGetInstanceFeatures")] public partial Status GetInstanceFeatures(ref InstanceFeatures features); + /// To be documented. + [NativeName("Src", "Line 3773, Column 22 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuGetProcAddress")] + public unsafe partial PfnProc GetProcAddress(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* procName); + + /// To be documented. + [NativeName("Src", "Line 3773, Column 22 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuGetProcAddress")] + public unsafe partial PfnProc GetProcAddress(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte procName); + + /// To be documented. + [NativeName("Src", "Line 3773, Column 22 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuGetProcAddress")] + public unsafe partial PfnProc GetProcAddress(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string procName); + /// To be documented. [NativeName("Src", "Line 3774, Column 18 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuSharedBufferMemoryEndAccessStateFreeMembers")] @@ -65,6 +80,16 @@ public unsafe partial class Dawn : NativeExtension [NativeApi(EntryPoint = "wgpuAdapterCreateDevice")] public unsafe partial Device* AdapterCreateDevice(Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DeviceDescriptor descriptor); + /// To be documented. + [NativeName("Src", "Line 3780, Column 20 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterEnumerateFeatures")] + public unsafe partial nuint AdapterEnumerateFeatures(Adapter* adapter, FeatureName* features); + + /// To be documented. + [NativeName("Src", "Line 3780, Column 20 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterEnumerateFeatures")] + public unsafe partial nuint AdapterEnumerateFeatures(Adapter* adapter, ref FeatureName features); + /// To be documented. [NativeName("Src", "Line 3781, Column 24 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuAdapterGetFormatCapabilities")] @@ -80,6 +105,26 @@ public unsafe partial class Dawn : NativeExtension [NativeApi(EntryPoint = "wgpuAdapterGetInstance")] public unsafe partial Instance* AdapterGetInstance(Adapter* adapter); + /// To be documented. + [NativeName("Src", "Line 3783, Column 24 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterGetLimits")] + public unsafe partial Status AdapterGetLimits(Adapter* adapter, SupportedLimits* limits); + + /// To be documented. + [NativeName("Src", "Line 3783, Column 24 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterGetLimits")] + public unsafe partial Status AdapterGetLimits(Adapter* adapter, ref SupportedLimits limits); + + /// To be documented. + [NativeName("Src", "Line 3784, Column 24 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterGetProperties")] + public unsafe partial Status AdapterGetProperties(Adapter* adapter, AdapterProperties* properties); + + /// To be documented. + [NativeName("Src", "Line 3784, Column 24 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterGetProperties")] + public unsafe partial Status AdapterGetProperties(Adapter* adapter, ref AdapterProperties properties); + /// To be documented. [NativeName("Src", "Line 3786, Column 18 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuAdapterRequestDevice")] @@ -121,19 +166,34 @@ public unsafe partial class Dawn : NativeExtension public unsafe partial Future AdapterRequestDeviceF(Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DeviceDescriptor options, RequestDeviceCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 3789, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterAddRef")] - public unsafe partial void AdapterAddRef(Adapter* adapter); + [NativeName("Src", "Line 3793, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuBindGroupSetLabel")] + public unsafe partial void BindGroupSetLabel(BindGroup* bindGroup, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 3793, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuBindGroupSetLabel")] + public unsafe partial void BindGroupSetLabel(BindGroup* bindGroup, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3793, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuBindGroupSetLabel")] + public unsafe partial void BindGroupSetLabel(BindGroup* bindGroup, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); /// To be documented. - [NativeName("Src", "Line 3794, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuBindGroupAddRef")] - public unsafe partial void BindGroupAddRef(BindGroup* bindGroup); + [NativeName("Src", "Line 3798, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuBindGroupLayoutSetLabel")] + public unsafe partial void BindGroupLayoutSetLabel(BindGroupLayout* bindGroupLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); /// To be documented. - [NativeName("Src", "Line 3799, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuBindGroupLayoutAddRef")] - public unsafe partial void BindGroupLayoutAddRef(BindGroupLayout* bindGroupLayout); + [NativeName("Src", "Line 3798, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuBindGroupLayoutSetLabel")] + public unsafe partial void BindGroupLayoutSetLabel(BindGroupLayout* bindGroupLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3798, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuBindGroupLayoutSetLabel")] + public unsafe partial void BindGroupLayoutSetLabel(BindGroupLayout* bindGroupLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); /// To be documented. [NativeName("Src", "Line 3809, Column 18 in dawn-webgpu.h")] @@ -151,14 +211,154 @@ public unsafe partial class Dawn : NativeExtension public unsafe partial Future BufferMapAsyncF(Buffer* buffer, Silk.NET.WebGPU.MapMode mode, nuint offset, nuint size, BufferMapCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 3813, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuBufferAddRef")] - public unsafe partial void BufferAddRef(Buffer* buffer); + [NativeName("Src", "Line 3811, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuBufferSetLabel")] + public unsafe partial void BufferSetLabel(Buffer* buffer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 3811, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuBufferSetLabel")] + public unsafe partial void BufferSetLabel(Buffer* buffer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3811, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuBufferSetLabel")] + public unsafe partial void BufferSetLabel(Buffer* buffer, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + + /// To be documented. + [NativeName("Src", "Line 3817, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandBufferSetLabel")] + public unsafe partial void CommandBufferSetLabel(CommandBuffer* commandBuffer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 3817, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandBufferSetLabel")] + public unsafe partial void CommandBufferSetLabel(CommandBuffer* commandBuffer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3817, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandBufferSetLabel")] + public unsafe partial void CommandBufferSetLabel(CommandBuffer* commandBuffer, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + + /// To be documented. + [NativeName("Src", "Line 3826, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3826, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + + /// To be documented. + [NativeName("Src", "Line 3826, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3826, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + + /// To be documented. + [NativeName("Src", "Line 3826, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3826, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + + /// To be documented. + [NativeName("Src", "Line 3826, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3826, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + + /// To be documented. + [NativeName("Src", "Line 3827, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3827, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + + /// To be documented. + [NativeName("Src", "Line 3827, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3827, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + + /// To be documented. + [NativeName("Src", "Line 3827, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3827, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + + /// To be documented. + [NativeName("Src", "Line 3827, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3827, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + + /// To be documented. + [NativeName("Src", "Line 3828, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3828, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + + /// To be documented. + [NativeName("Src", "Line 3828, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3828, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 3818, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandBufferAddRef")] - public unsafe partial void CommandBufferAddRef(CommandBuffer* commandBuffer); + [NativeName("Src", "Line 3828, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3828, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + + /// To be documented. + [NativeName("Src", "Line 3828, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + + /// To be documented. + [NativeName("Src", "Line 3828, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. [NativeName("Src", "Line 3830, Column 18 in dawn-webgpu.h")] @@ -175,6 +375,51 @@ public unsafe partial class Dawn : NativeExtension [NativeApi(EntryPoint = "wgpuCommandEncoderInjectValidationError")] public unsafe partial void CommandEncoderInjectValidationError(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string message); + /// To be documented. + [NativeName("Src", "Line 3831, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderInsertDebugMarker")] + public unsafe partial void CommandEncoderInsertDebugMarker(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* markerLabel); + + /// To be documented. + [NativeName("Src", "Line 3831, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderInsertDebugMarker")] + public unsafe partial void CommandEncoderInsertDebugMarker(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte markerLabel); + + /// To be documented. + [NativeName("Src", "Line 3831, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderInsertDebugMarker")] + public unsafe partial void CommandEncoderInsertDebugMarker(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string markerLabel); + + /// To be documented. + [NativeName("Src", "Line 3833, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderPushDebugGroup")] + public unsafe partial void CommandEncoderPushDebugGroup(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* groupLabel); + + /// To be documented. + [NativeName("Src", "Line 3833, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderPushDebugGroup")] + public unsafe partial void CommandEncoderPushDebugGroup(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte groupLabel); + + /// To be documented. + [NativeName("Src", "Line 3833, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderPushDebugGroup")] + public unsafe partial void CommandEncoderPushDebugGroup(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string groupLabel); + + /// To be documented. + [NativeName("Src", "Line 3835, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderSetLabel")] + public unsafe partial void CommandEncoderSetLabel(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 3835, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderSetLabel")] + public unsafe partial void CommandEncoderSetLabel(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3835, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderSetLabel")] + public unsafe partial void CommandEncoderSetLabel(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + /// To be documented. [NativeName("Src", "Line 3836, Column 18 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderWriteBuffer")] @@ -191,9 +436,49 @@ public unsafe partial class Dawn : NativeExtension public unsafe partial void CommandEncoderWriteBuffer(CommandEncoder* commandEncoder, Buffer* buffer, ulong bufferOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string data, ulong size); /// To be documented. - [NativeName("Src", "Line 3838, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandEncoderAddRef")] - public unsafe partial void CommandEncoderAddRef(CommandEncoder* commandEncoder); + [NativeName("Src", "Line 3845, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderInsertDebugMarker")] + public unsafe partial void ComputePassEncoderInsertDebugMarker(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* markerLabel); + + /// To be documented. + [NativeName("Src", "Line 3845, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderInsertDebugMarker")] + public unsafe partial void ComputePassEncoderInsertDebugMarker(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte markerLabel); + + /// To be documented. + [NativeName("Src", "Line 3845, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderInsertDebugMarker")] + public unsafe partial void ComputePassEncoderInsertDebugMarker(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string markerLabel); + + /// To be documented. + [NativeName("Src", "Line 3847, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderPushDebugGroup")] + public unsafe partial void ComputePassEncoderPushDebugGroup(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* groupLabel); + + /// To be documented. + [NativeName("Src", "Line 3847, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderPushDebugGroup")] + public unsafe partial void ComputePassEncoderPushDebugGroup(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte groupLabel); + + /// To be documented. + [NativeName("Src", "Line 3847, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderPushDebugGroup")] + public unsafe partial void ComputePassEncoderPushDebugGroup(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string groupLabel); + + /// To be documented. + [NativeName("Src", "Line 3849, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderSetLabel")] + public unsafe partial void ComputePassEncoderSetLabel(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 3849, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderSetLabel")] + public unsafe partial void ComputePassEncoderSetLabel(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3849, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderSetLabel")] + public unsafe partial void ComputePassEncoderSetLabel(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); /// To be documented. [NativeName("Src", "Line 3851, Column 18 in dawn-webgpu.h")] @@ -201,14 +486,19 @@ public unsafe partial class Dawn : NativeExtension public unsafe partial void ComputePassEncoderWriteTimestamp(ComputePassEncoder* computePassEncoder, QuerySet* querySet, uint queryIndex); /// To be documented. - [NativeName("Src", "Line 3852, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePassEncoderAddRef")] - public unsafe partial void ComputePassEncoderAddRef(ComputePassEncoder* computePassEncoder); + [NativeName("Src", "Line 3857, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePipelineSetLabel")] + public unsafe partial void ComputePipelineSetLabel(ComputePipeline* computePipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); /// To be documented. - [NativeName("Src", "Line 3858, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePipelineAddRef")] - public unsafe partial void ComputePipelineAddRef(ComputePipeline* computePipeline); + [NativeName("Src", "Line 3857, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePipelineSetLabel")] + public unsafe partial void ComputePipelineSetLabel(ComputePipeline* computePipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3857, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePipelineSetLabel")] + public unsafe partial void ComputePipelineSetLabel(ComputePipeline* computePipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); /// To be documented. [NativeName("Src", "Line 3867, Column 18 in dawn-webgpu.h")] @@ -345,6 +635,16 @@ public unsafe partial class Dawn : NativeExtension [NativeApi(EntryPoint = "wgpuDeviceCreateSwapChain")] public unsafe partial SwapChain* DeviceCreateSwapChain(Device* device, Surface* surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly SwapChainDescriptor descriptor); + /// To be documented. + [NativeName("Src", "Line 3885, Column 20 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceEnumerateFeatures")] + public unsafe partial nuint DeviceEnumerateFeatures(Device* device, FeatureName* features); + + /// To be documented. + [NativeName("Src", "Line 3885, Column 20 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceEnumerateFeatures")] + public unsafe partial nuint DeviceEnumerateFeatures(Device* device, ref FeatureName features); + /// To be documented. [NativeName("Src", "Line 3886, Column 18 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceForceLoss")] @@ -365,6 +665,16 @@ public unsafe partial class Dawn : NativeExtension [NativeApi(EntryPoint = "wgpuDeviceGetAdapter")] public unsafe partial Adapter* DeviceGetAdapter(Device* device); + /// To be documented. + [NativeName("Src", "Line 3888, Column 24 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceGetLimits")] + public unsafe partial Status DeviceGetLimits(Device* device, SupportedLimits* limits); + + /// To be documented. + [NativeName("Src", "Line 3888, Column 24 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceGetLimits")] + public unsafe partial Status DeviceGetLimits(Device* device, ref SupportedLimits limits); + /// To be documented. [NativeName("Src", "Line 3890, Column 35 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceGetSupportedSurfaceUsage")] @@ -415,6 +725,16 @@ public unsafe partial class Dawn : NativeExtension [NativeApi(EntryPoint = "wgpuDeviceInjectError")] public unsafe partial void DeviceInjectError(Device* device, ErrorType type, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string message); + /// To be documented. + [NativeName("Src", "Line 3896, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuDevicePopErrorScope")] + public unsafe partial void DevicePopErrorScope(Device* device, PfnErrorCallback oldCallback, void* userdata); + + /// To be documented. + [NativeName("Src", "Line 3896, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuDevicePopErrorScope")] + public unsafe partial void DevicePopErrorScope(Device* device, PfnErrorCallback oldCallback, ref T0 userdata) where T0 : unmanaged; + /// To be documented. [NativeName("Src", "Line 3897, Column 24 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuDevicePopErrorScope2")] @@ -435,6 +755,21 @@ public unsafe partial class Dawn : NativeExtension [NativeApi(EntryPoint = "wgpuDeviceSetDeviceLostCallback")] public unsafe partial void DeviceSetDeviceLostCallback(Device* device, PfnDeviceLostCallback callback, ref T0 userdata) where T0 : unmanaged; + /// To be documented. + [NativeName("Src", "Line 3901, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceSetLabel")] + public unsafe partial void DeviceSetLabel(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 3901, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceSetLabel")] + public unsafe partial void DeviceSetLabel(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3901, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceSetLabel")] + public unsafe partial void DeviceSetLabel(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + /// To be documented. [NativeName("Src", "Line 3902, Column 18 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceSetLoggingCallback")] @@ -445,6 +780,16 @@ public unsafe partial class Dawn : NativeExtension [NativeApi(EntryPoint = "wgpuDeviceSetLoggingCallback")] public unsafe partial void DeviceSetLoggingCallback(Device* device, PfnLoggingCallback callback, ref T0 userdata) where T0 : unmanaged; + /// To be documented. + [NativeName("Src", "Line 3903, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceSetUncapturedErrorCallback")] + public unsafe partial void DeviceSetUncapturedErrorCallback(Device* device, PfnErrorCallback callback, void* userdata); + + /// To be documented. + [NativeName("Src", "Line 3903, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceSetUncapturedErrorCallback")] + public unsafe partial void DeviceSetUncapturedErrorCallback(Device* device, PfnErrorCallback callback, ref T0 userdata) where T0 : unmanaged; + /// To be documented. [NativeName("Src", "Line 3904, Column 18 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceTick")] @@ -460,11 +805,6 @@ public unsafe partial class Dawn : NativeExtension [NativeApi(EntryPoint = "wgpuDeviceValidateTextureDescriptor")] public unsafe partial void DeviceValidateTextureDescriptor(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDescriptor descriptor); - /// To be documented. - [NativeName("Src", "Line 3906, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceAddRef")] - public unsafe partial void DeviceAddRef(Device* device); - /// To be documented. [NativeName("Src", "Line 3910, Column 18 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuExternalTextureDestroy")] @@ -515,6 +855,11 @@ public unsafe partial class Dawn : NativeExtension [NativeApi(EntryPoint = "wgpuInstanceEnumerateWGSLLanguageFeatures")] public unsafe partial nuint InstanceEnumerateWGSLLanguageFeatures(Instance* instance, ref WGSLFeatureName features); + /// To be documented. + [NativeName("Src", "Line 3920, Column 22 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuInstanceHasWGSLLanguageFeature")] + public unsafe partial Silk.NET.Core.Bool32 InstanceHasWGSLLanguageFeature(Instance* instance, WGSLFeatureName feature); + /// To be documented. [NativeName("Src", "Line 3922, Column 18 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceRequestAdapter")] @@ -556,29 +901,34 @@ public unsafe partial class Dawn : NativeExtension public unsafe partial Future InstanceRequestAdapterF(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly RequestAdapterOptions options, RequestAdapterCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 3925, Column 28 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuInstanceWaitAny")] - public unsafe partial WaitStatus InstanceWaitAny(Instance* instance, nuint futureCount, FutureWaitInfo* futures, ulong timeoutNS); + [NativeName("Src", "Line 3930, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuPipelineLayoutSetLabel")] + public unsafe partial void PipelineLayoutSetLabel(PipelineLayout* pipelineLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 3930, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuPipelineLayoutSetLabel")] + public unsafe partial void PipelineLayoutSetLabel(PipelineLayout* pipelineLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); /// To be documented. - [NativeName("Src", "Line 3925, Column 28 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuInstanceWaitAny")] - public unsafe partial WaitStatus InstanceWaitAny(Instance* instance, nuint futureCount, ref FutureWaitInfo futures, ulong timeoutNS); + [NativeName("Src", "Line 3930, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuPipelineLayoutSetLabel")] + public unsafe partial void PipelineLayoutSetLabel(PipelineLayout* pipelineLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); /// To be documented. - [NativeName("Src", "Line 3926, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuInstanceAddRef")] - public unsafe partial void InstanceAddRef(Instance* instance); + [NativeName("Src", "Line 3938, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQuerySetSetLabel")] + public unsafe partial void QuerySetSetLabel(QuerySet* querySet, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); /// To be documented. - [NativeName("Src", "Line 3931, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuPipelineLayoutAddRef")] - public unsafe partial void PipelineLayoutAddRef(PipelineLayout* pipelineLayout); + [NativeName("Src", "Line 3938, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQuerySetSetLabel")] + public unsafe partial void QuerySetSetLabel(QuerySet* querySet, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); /// To be documented. - [NativeName("Src", "Line 3939, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuQuerySetAddRef")] - public unsafe partial void QuerySetAddRef(QuerySet* querySet); + [NativeName("Src", "Line 3938, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQuerySetSetLabel")] + public unsafe partial void QuerySetSetLabel(QuerySet* querySet, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); /// To be documented. [NativeName("Src", "Line 3943, Column 18 in dawn-webgpu.h")] @@ -756,44 +1106,244 @@ public unsafe partial class Dawn : NativeExtension public unsafe partial Future QueueOnSubmittedWorkDoneF(Queue* queue, QueueWorkDoneCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 3951, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuQueueAddRef")] - public unsafe partial void QueueAddRef(Queue* queue); + [NativeName("Src", "Line 3947, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueSetLabel")] + public unsafe partial void QueueSetLabel(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 3947, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueSetLabel")] + public unsafe partial void QueueSetLabel(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3947, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueSetLabel")] + public unsafe partial void QueueSetLabel(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 3950, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 3955, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleSetLabel")] + public unsafe partial void RenderBundleSetLabel(RenderBundle* renderBundle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 3955, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleSetLabel")] + public unsafe partial void RenderBundleSetLabel(RenderBundle* renderBundle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3955, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleSetLabel")] + public unsafe partial void RenderBundleSetLabel(RenderBundle* renderBundle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + + /// To be documented. + [NativeName("Src", "Line 3965, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderInsertDebugMarker")] + public unsafe partial void RenderBundleEncoderInsertDebugMarker(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* markerLabel); + + /// To be documented. + [NativeName("Src", "Line 3965, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderInsertDebugMarker")] + public unsafe partial void RenderBundleEncoderInsertDebugMarker(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte markerLabel); + + /// To be documented. + [NativeName("Src", "Line 3965, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderInsertDebugMarker")] + public unsafe partial void RenderBundleEncoderInsertDebugMarker(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string markerLabel); /// To be documented. - [NativeName("Src", "Line 3956, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleAddRef")] - public unsafe partial void RenderBundleAddRef(RenderBundle* renderBundle); + [NativeName("Src", "Line 3967, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderPushDebugGroup")] + public unsafe partial void RenderBundleEncoderPushDebugGroup(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* groupLabel); /// To be documented. - [NativeName("Src", "Line 3973, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleEncoderAddRef")] - public unsafe partial void RenderBundleEncoderAddRef(RenderBundleEncoder* renderBundleEncoder); + [NativeName("Src", "Line 3967, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderPushDebugGroup")] + public unsafe partial void RenderBundleEncoderPushDebugGroup(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte groupLabel); + + /// To be documented. + [NativeName("Src", "Line 3967, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderPushDebugGroup")] + public unsafe partial void RenderBundleEncoderPushDebugGroup(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string groupLabel); + + /// To be documented. + [NativeName("Src", "Line 3970, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetLabel")] + public unsafe partial void RenderBundleEncoderSetLabel(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 3970, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetLabel")] + public unsafe partial void RenderBundleEncoderSetLabel(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3970, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetLabel")] + public unsafe partial void RenderBundleEncoderSetLabel(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + + /// To be documented. + [NativeName("Src", "Line 3985, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPassEncoderInsertDebugMarker")] + public unsafe partial void RenderPassEncoderInsertDebugMarker(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* markerLabel); + + /// To be documented. + [NativeName("Src", "Line 3985, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPassEncoderInsertDebugMarker")] + public unsafe partial void RenderPassEncoderInsertDebugMarker(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte markerLabel); + + /// To be documented. + [NativeName("Src", "Line 3985, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPassEncoderInsertDebugMarker")] + public unsafe partial void RenderPassEncoderInsertDebugMarker(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string markerLabel); /// To be documented. [NativeName("Src", "Line 3986, Column 18 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderPixelLocalStorageBarrier")] public unsafe partial void RenderPassEncoderPixelLocalStorageBarrier(RenderPassEncoder* renderPassEncoder); + /// To be documented. + [NativeName("Src", "Line 3988, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPassEncoderPushDebugGroup")] + public unsafe partial void RenderPassEncoderPushDebugGroup(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* groupLabel); + + /// To be documented. + [NativeName("Src", "Line 3988, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPassEncoderPushDebugGroup")] + public unsafe partial void RenderPassEncoderPushDebugGroup(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte groupLabel); + + /// To be documented. + [NativeName("Src", "Line 3988, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPassEncoderPushDebugGroup")] + public unsafe partial void RenderPassEncoderPushDebugGroup(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string groupLabel); + + /// To be documented. + [NativeName("Src", "Line 3992, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetLabel")] + public unsafe partial void RenderPassEncoderSetLabel(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 3992, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetLabel")] + public unsafe partial void RenderPassEncoderSetLabel(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 3992, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetLabel")] + public unsafe partial void RenderPassEncoderSetLabel(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + /// To be documented. [NativeName("Src", "Line 3998, Column 18 in dawn-webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderWriteTimestamp")] public unsafe partial void RenderPassEncoderWriteTimestamp(RenderPassEncoder* renderPassEncoder, QuerySet* querySet, uint queryIndex); /// To be documented. - [NativeName("Src", "Line 3999, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPassEncoderAddRef")] - public unsafe partial void RenderPassEncoderAddRef(RenderPassEncoder* renderPassEncoder); + [NativeName("Src", "Line 4004, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPipelineSetLabel")] + public unsafe partial void RenderPipelineSetLabel(RenderPipeline* renderPipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 4004, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPipelineSetLabel")] + public unsafe partial void RenderPipelineSetLabel(RenderPipeline* renderPipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 4004, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPipelineSetLabel")] + public unsafe partial void RenderPipelineSetLabel(RenderPipeline* renderPipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); /// To be documented. - [NativeName("Src", "Line 4005, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPipelineAddRef")] - public unsafe partial void RenderPipelineAddRef(RenderPipeline* renderPipeline); + [NativeName("Src", "Line 4009, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuSamplerSetLabel")] + public unsafe partial void SamplerSetLabel(Sampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); /// To be documented. - [NativeName("Src", "Line 4010, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuSamplerAddRef")] - public unsafe partial void SamplerAddRef(Sampler* sampler); + [NativeName("Src", "Line 4009, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuSamplerSetLabel")] + public unsafe partial void SamplerSetLabel(Sampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 4009, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuSamplerSetLabel")] + public unsafe partial void SamplerSetLabel(Sampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); /// To be documented. [NativeName("Src", "Line 4014, Column 18 in dawn-webgpu.h")] @@ -811,9 +1361,19 @@ public unsafe partial class Dawn : NativeExtension public unsafe partial Future ShaderModuleGetCompilationInfoF(ShaderModule* shaderModule, CompilationInfoCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 4017, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuShaderModuleAddRef")] - public unsafe partial void ShaderModuleAddRef(ShaderModule* shaderModule); + [NativeName("Src", "Line 4016, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuShaderModuleSetLabel")] + public unsafe partial void ShaderModuleSetLabel(ShaderModule* shaderModule, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 4016, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuShaderModuleSetLabel")] + public unsafe partial void ShaderModuleSetLabel(ShaderModule* shaderModule, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 4016, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuShaderModuleSetLabel")] + public unsafe partial void ShaderModuleSetLabel(ShaderModule* shaderModule, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); /// To be documented. [NativeName("Src", "Line 4021, Column 22 in dawn-webgpu.h")] @@ -976,9 +1536,9 @@ public unsafe partial class Dawn : NativeExtension public unsafe partial void SharedTextureMemoryRelease(SharedTextureMemoryImpl* sharedTextureMemory); /// To be documented. - [NativeName("Src", "Line 4052, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuSurfaceAddRef")] - public unsafe partial void SurfaceAddRef(Surface* surface); + [NativeName("Src", "Line 4049, Column 31 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuSurfaceGetPreferredFormat")] + public unsafe partial TextureFormat SurfaceGetPreferredFormat(Surface* surface, Adapter* adapter); /// To be documented. [NativeName("Src", "Line 4056, Column 25 in dawn-webgpu.h")] @@ -1016,14 +1576,34 @@ public unsafe partial class Dawn : NativeExtension public unsafe partial TextureView* TextureCreateErrorView(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureViewDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 4075, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuTextureAddRef")] - public unsafe partial void TextureAddRef(Texture* texture); + [NativeName("Src", "Line 4074, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuTextureSetLabel")] + public unsafe partial void TextureSetLabel(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 4074, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuTextureSetLabel")] + public unsafe partial void TextureSetLabel(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + + /// To be documented. + [NativeName("Src", "Line 4074, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuTextureSetLabel")] + public unsafe partial void TextureSetLabel(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + + /// To be documented. + [NativeName("Src", "Line 4079, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuTextureViewSetLabel")] + public unsafe partial void TextureViewSetLabel(TextureView* textureView, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + + /// To be documented. + [NativeName("Src", "Line 4079, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuTextureViewSetLabel")] + public unsafe partial void TextureViewSetLabel(TextureView* textureView, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); /// To be documented. - [NativeName("Src", "Line 4080, Column 18 in dawn-webgpu.h")] - [NativeApi(EntryPoint = "wgpuTextureViewAddRef")] - public unsafe partial void TextureViewAddRef(TextureView* textureView); + [NativeName("Src", "Line 4079, Column 18 in dawn-webgpu.h")] + [NativeApi(EntryPoint = "wgpuTextureViewSetLabel")] + public unsafe partial void TextureViewSetLabel(TextureView* textureView, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); public Dawn(INativeContext ctx) : base(ctx) diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/DawnOverloads.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/DawnOverloads.gen.cs index 3fbd464904..a48f1c310c 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/DawnOverloads.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/DawnOverloads.gen.cs @@ -17,19 +17,19 @@ namespace Silk.NET.WebGPU.Extensions.Dawn public static class DawnOverloads { /// To be documented. - [NativeName("Src", "Line 3772, Column 24 in dawn-webgpu.h")] - public static unsafe Status GetInstanceFeatures(this Dawn thisApi, Span features) + [NativeName("Src", "Line 3779, Column 24 in dawn-webgpu.h")] + public static unsafe Device* AdapterCreateDevice(this Dawn thisApi, Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader - return thisApi.GetInstanceFeatures(ref features.GetPinnableReference()); + return thisApi.AdapterCreateDevice(adapter, in descriptor.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 3779, Column 24 in dawn-webgpu.h")] - public static unsafe Device* AdapterCreateDevice(this Dawn thisApi, Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) + [NativeName("Src", "Line 3780, Column 20 in dawn-webgpu.h")] + public static unsafe nuint AdapterEnumerateFeatures(this Dawn thisApi, Adapter* adapter, Span features) { // SpanOverloader - return thisApi.AdapterCreateDevice(adapter, in descriptor.GetPinnableReference()); + return thisApi.AdapterEnumerateFeatures(adapter, ref features.GetPinnableReference()); } /// To be documented. @@ -40,6 +40,14 @@ public static unsafe Status AdapterGetFormatCapabilities(this Dawn thisApi, Adap return thisApi.AdapterGetFormatCapabilities(adapter, format, ref capabilities.GetPinnableReference()); } + /// To be documented. + [NativeName("Src", "Line 3784, Column 24 in dawn-webgpu.h")] + public static unsafe Status AdapterGetProperties(this Dawn thisApi, Adapter* adapter, Span properties) + { + // SpanOverloader + return thisApi.AdapterGetProperties(adapter, ref properties.GetPinnableReference()); + } + /// To be documented. [NativeName("Src", "Line 3787, Column 24 in dawn-webgpu.h")] public static unsafe Future AdapterRequestDevice2(this Dawn thisApi, Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan options, RequestDeviceCallbackInfo2 callbackInfo) @@ -152,6 +160,14 @@ public static unsafe Future DeviceCreateRenderPipelineAsyncF(this Dawn thisApi, return thisApi.DeviceCreateSwapChain(device, surface, in descriptor.GetPinnableReference()); } + /// To be documented. + [NativeName("Src", "Line 3885, Column 20 in dawn-webgpu.h")] + public static unsafe nuint DeviceEnumerateFeatures(this Dawn thisApi, Device* device, Span features) + { + // SpanOverloader + return thisApi.DeviceEnumerateFeatures(device, ref features.GetPinnableReference()); + } + /// To be documented. [NativeName("Src", "Line 3886, Column 18 in dawn-webgpu.h")] public static unsafe void DeviceForceLoss(this Dawn thisApi, Device* device, DeviceLostReason type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan message) @@ -208,6 +224,14 @@ public static unsafe void DeviceSetLoggingCallback(this Dawn thisApi, Device thisApi.DeviceSetLoggingCallback(device, callback, ref userdata.GetPinnableReference()); } + /// To be documented. + [NativeName("Src", "Line 3903, Column 18 in dawn-webgpu.h")] + public static unsafe void DeviceSetUncapturedErrorCallback(this Dawn thisApi, Device* device, PfnErrorCallback callback, Span userdata) where T0 : unmanaged + { + // SpanOverloader + thisApi.DeviceSetUncapturedErrorCallback(device, callback, ref userdata.GetPinnableReference()); + } + /// To be documented. [NativeName("Src", "Line 3905, Column 18 in dawn-webgpu.h")] public static unsafe void DeviceValidateTextureDescriptor(this Dawn thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) @@ -248,14 +272,6 @@ public static unsafe Future InstanceRequestAdapterF(this Dawn thisApi, Instance* return thisApi.InstanceRequestAdapterF(instance, in options.GetPinnableReference(), callbackInfo); } - /// To be documented. - [NativeName("Src", "Line 3925, Column 28 in dawn-webgpu.h")] - public static unsafe WaitStatus InstanceWaitAny(this Dawn thisApi, Instance* instance, nuint futureCount, Span futures, ulong timeoutNS) - { - // SpanOverloader - return thisApi.InstanceWaitAny(instance, futureCount, ref futures.GetPinnableReference(), timeoutNS); - } - /// To be documented. [NativeName("Src", "Line 3943, Column 18 in dawn-webgpu.h")] public static unsafe void QueueCopyExternalTextureForBrowser(this Dawn thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyExternalTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan options) diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/BufferMapAsyncStatus.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/BufferMapAsyncStatus.gen.cs similarity index 73% rename from src/WebGPU/Silk.NET.WebGPU/Enums/BufferMapAsyncStatus.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/BufferMapAsyncStatus.gen.cs index 6685f6ac68..e0a000e532 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/BufferMapAsyncStatus.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/BufferMapAsyncStatus.gen.cs @@ -7,29 +7,31 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUBufferMapAsyncStatus")] public enum BufferMapAsyncStatus : int { [NativeName("Name", "WGPUBufferMapAsyncStatus_Success")] Success = 0x0, + [NativeName("Name", "WGPUBufferMapAsyncStatus_InstanceDropped")] + InstanceDropped = 0x1, [NativeName("Name", "WGPUBufferMapAsyncStatus_ValidationError")] - ValidationError = 0x1, + ValidationError = 0x2, [NativeName("Name", "WGPUBufferMapAsyncStatus_Unknown")] - Unknown = 0x2, + Unknown = 0x3, [NativeName("Name", "WGPUBufferMapAsyncStatus_DeviceLost")] - DeviceLost = 0x3, + DeviceLost = 0x4, [NativeName("Name", "WGPUBufferMapAsyncStatus_DestroyedBeforeCallback")] - DestroyedBeforeCallback = 0x4, + DestroyedBeforeCallback = 0x5, [NativeName("Name", "WGPUBufferMapAsyncStatus_UnmappedBeforeCallback")] - UnmappedBeforeCallback = 0x5, + UnmappedBeforeCallback = 0x6, [NativeName("Name", "WGPUBufferMapAsyncStatus_MappingAlreadyPending")] - MappingAlreadyPending = 0x6, + MappingAlreadyPending = 0x7, [NativeName("Name", "WGPUBufferMapAsyncStatus_OffsetOutOfRange")] - OffsetOutOfRange = 0x7, + OffsetOutOfRange = 0x8, [NativeName("Name", "WGPUBufferMapAsyncStatus_SizeOutOfRange")] - SizeOutOfRange = 0x8, + SizeOutOfRange = 0x9, [NativeName("Name", "WGPUBufferMapAsyncStatus_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/BufferUsage.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/BufferUsage.gen.cs similarity index 96% rename from src/WebGPU/Silk.NET.WebGPU/Enums/BufferUsage.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/BufferUsage.gen.cs index 650306c222..c1ce376eb5 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/BufferUsage.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/BufferUsage.gen.cs @@ -7,7 +7,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [Flags] [NativeName("Name", "WGPUBufferUsage")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/ColorWriteMask.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/ColorWriteMask.gen.cs similarity index 95% rename from src/WebGPU/Silk.NET.WebGPU/Enums/ColorWriteMask.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/ColorWriteMask.gen.cs index fe342c0535..9cd4f265a6 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/ColorWriteMask.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/ColorWriteMask.gen.cs @@ -7,7 +7,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [Flags] [NativeName("Name", "WGPUColorWriteMask")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/MapMode.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/MapMode.gen.cs similarity index 93% rename from src/WebGPU/Silk.NET.WebGPU/Enums/MapMode.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/MapMode.gen.cs index 43b8ce55b7..57c8d58b23 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/MapMode.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/MapMode.gen.cs @@ -7,7 +7,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUMapMode")] public enum MapMode : int diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/ShaderStage.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/ShaderStage.gen.cs similarity index 94% rename from src/WebGPU/Silk.NET.WebGPU/Enums/ShaderStage.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/ShaderStage.gen.cs index 0113c69b51..b23d3c7471 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/ShaderStage.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/ShaderStage.gen.cs @@ -7,7 +7,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [Flags] [NativeName("Name", "WGPUShaderStage")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/TextureUsage.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/TextureUsage.gen.cs similarity index 78% rename from src/WebGPU/Silk.NET.WebGPU/Enums/TextureUsage.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/TextureUsage.gen.cs index a7f7f6accb..22a23a120b 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/TextureUsage.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/TextureUsage.gen.cs @@ -7,7 +7,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [Flags] [NativeName("Name", "WGPUTextureUsage")] @@ -25,6 +25,10 @@ public enum TextureUsage : int StorageBinding = 0x8, [NativeName("Name", "WGPUTextureUsage_RenderAttachment")] RenderAttachment = 0x10, + [NativeName("Name", "WGPUTextureUsage_TransientAttachment")] + TransientAttachment = 0x20, + [NativeName("Name", "WGPUTextureUsage_StorageAttachment")] + StorageAttachment = 0x40, [NativeName("Name", "WGPUTextureUsage_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/WGSLFeatureName.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/WGSLFeatureName.gen.cs similarity index 59% rename from src/WebGPU/Silk.NET.WebGPU/Enums/WGSLFeatureName.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/WGSLFeatureName.gen.cs index 9d9ffb62b9..c9b1786d37 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/WGSLFeatureName.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/WGSLFeatureName.gen.cs @@ -7,7 +7,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUWGSLFeatureName")] public enum WGSLFeatureName : int @@ -22,6 +22,16 @@ public enum WGSLFeatureName : int UnrestrictedPointerParameters = 0x3, [NativeName("Name", "WGPUWGSLFeatureName_PointerCompositeAccess")] PointerCompositeAccess = 0x4, + [NativeName("Name", "WGPUWGSLFeatureName_ChromiumTestingUnimplemented")] + ChromiumTestingUnimplemented = 0x3E8, + [NativeName("Name", "WGPUWGSLFeatureName_ChromiumTestingUnsafeExperimental")] + ChromiumTestingUnsafeExperimental = 0x3E9, + [NativeName("Name", "WGPUWGSLFeatureName_ChromiumTestingExperimental")] + ChromiumTestingExperimental = 0x3EA, + [NativeName("Name", "WGPUWGSLFeatureName_ChromiumTestingShippedWithKillswitch")] + ChromiumTestingShippedWithKillswitch = 0x3EB, + [NativeName("Name", "WGPUWGSLFeatureName_ChromiumTestingShipped")] + ChromiumTestingShipped = 0x3EC, [NativeName("Name", "WGPUWGSLFeatureName_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/AdapterProperties.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/AdapterProperties.gen.cs similarity index 88% rename from src/WebGPU/Silk.NET.WebGPU/Structs/AdapterProperties.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/AdapterProperties.gen.cs index c24878876d..b7af99269c 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/AdapterProperties.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/AdapterProperties.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUAdapterProperties")] public unsafe partial struct AdapterProperties @@ -29,7 +29,8 @@ public AdapterProperties byte* name = null, byte* driverDescription = null, AdapterType? adapterType = null, - BackendType? backendType = null + BackendType? backendType = null, + Silk.NET.Core.Bool32? compatibilityMode = null ) : this() { if (nextInChain is not null) @@ -76,6 +77,11 @@ public AdapterProperties { BackendType = backendType.Value; } + + if (compatibilityMode is not null) + { + CompatibilityMode = compatibilityMode.Value; + } } @@ -123,5 +129,10 @@ public AdapterProperties [NativeName("Type.Name", "WGPUBackendType")] [NativeName("Name", "backendType")] public BackendType BackendType; + + [NativeName("Type", "WGPUBool")] + [NativeName("Type.Name", "WGPUBool")] + [NativeName("Name", "compatibilityMode")] + public Silk.NET.Core.Bool32 CompatibilityMode; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ChainedStructOut.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ChainedStructOut.gen.cs similarity index 96% rename from src/WebGPU/Silk.NET.WebGPU/Structs/ChainedStructOut.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ChainedStructOut.gen.cs index b1ced8572c..d1c68b9d3c 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ChainedStructOut.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ChainedStructOut.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUChainedStructOut")] public unsafe partial struct ChainedStructOut diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ComputePassTimestampWrites.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ComputePassTimestampWrites.gen.cs similarity index 97% rename from src/WebGPU/Silk.NET.WebGPU/Structs/ComputePassTimestampWrites.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ComputePassTimestampWrites.gen.cs index c011ff6729..887c0ff9ad 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ComputePassTimestampWrites.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ComputePassTimestampWrites.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUComputePassTimestampWrites")] public unsafe partial struct ComputePassTimestampWrites diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ImageCopyBuffer.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ImageCopyBuffer.gen.cs similarity index 75% rename from src/WebGPU/Silk.NET.WebGPU/Structs/ImageCopyBuffer.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ImageCopyBuffer.gen.cs index a06ef6015b..842ceea2c9 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ImageCopyBuffer.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ImageCopyBuffer.gen.cs @@ -14,23 +14,17 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUImageCopyBuffer")] public unsafe partial struct ImageCopyBuffer { public ImageCopyBuffer ( - ChainedStruct* nextInChain = null, TextureDataLayout? layout = null, Buffer* buffer = null ) : this() { - if (nextInChain is not null) - { - NextInChain = nextInChain; - } - if (layout is not null) { Layout = layout.Value; @@ -43,11 +37,6 @@ public ImageCopyBuffer } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] - [NativeName("Name", "nextInChain")] - public ChainedStruct* NextInChain; - [NativeName("Type", "WGPUTextureDataLayout")] [NativeName("Type.Name", "WGPUTextureDataLayout")] [NativeName("Name", "layout")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ImageCopyTexture.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ImageCopyTexture.gen.cs similarity index 82% rename from src/WebGPU/Silk.NET.WebGPU/Structs/ImageCopyTexture.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ImageCopyTexture.gen.cs index f68b6a8d43..ae3c7657cf 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ImageCopyTexture.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ImageCopyTexture.gen.cs @@ -14,25 +14,19 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUImageCopyTexture")] public unsafe partial struct ImageCopyTexture { public ImageCopyTexture ( - ChainedStruct* nextInChain = null, Texture* texture = null, uint? mipLevel = null, Origin3D? origin = null, TextureAspect? aspect = null ) : this() { - if (nextInChain is not null) - { - NextInChain = nextInChain; - } - if (texture is not null) { Texture = texture; @@ -55,11 +49,6 @@ public ImageCopyTexture } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] - [NativeName("Name", "nextInChain")] - public ChainedStruct* NextInChain; - [NativeName("Type", "WGPUTexture")] [NativeName("Type.Name", "WGPUTexture")] [NativeName("Name", "texture")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnErrorCallback.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PfnErrorCallback.gen.cs similarity index 98% rename from src/WebGPU/Silk.NET.WebGPU/Structs/PfnErrorCallback.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PfnErrorCallback.gen.cs index 2175574fba..d2746b5760 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnErrorCallback.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PfnErrorCallback.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { public unsafe readonly struct PfnErrorCallback : IDisposable { diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PrimitiveDepthClipControl.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PrimitiveDepthClipControl.gen.cs similarity index 96% rename from src/WebGPU/Silk.NET.WebGPU/Structs/PrimitiveDepthClipControl.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PrimitiveDepthClipControl.gen.cs index 8bd38b2df6..5dbf69fe49 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PrimitiveDepthClipControl.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PrimitiveDepthClipControl.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUPrimitiveDepthClipControl")] public unsafe partial struct PrimitiveDepthClipControl diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ProgrammableStageDescriptor.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ProgrammableStageDescriptor.gen.cs similarity index 98% rename from src/WebGPU/Silk.NET.WebGPU/Structs/ProgrammableStageDescriptor.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ProgrammableStageDescriptor.gen.cs index ad58c18a2d..ebef3d6a5a 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ProgrammableStageDescriptor.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ProgrammableStageDescriptor.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUProgrammableStageDescriptor")] public unsafe partial struct ProgrammableStageDescriptor diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassDescriptorMaxDrawCount.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RenderPassDescriptorMaxDrawCount.gen.cs similarity index 96% rename from src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassDescriptorMaxDrawCount.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RenderPassDescriptorMaxDrawCount.gen.cs index ec04262662..1ff2d86785 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassDescriptorMaxDrawCount.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RenderPassDescriptorMaxDrawCount.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPURenderPassDescriptorMaxDrawCount")] public unsafe partial struct RenderPassDescriptorMaxDrawCount diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassTimestampWrites.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RenderPassTimestampWrites.gen.cs similarity index 97% rename from src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassTimestampWrites.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RenderPassTimestampWrites.gen.cs index 41e598f0a5..3ebca3e06b 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassTimestampWrites.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RenderPassTimestampWrites.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPURenderPassTimestampWrites")] public unsafe partial struct RenderPassTimestampWrites diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RequiredLimits.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RequiredLimits.gen.cs similarity index 96% rename from src/WebGPU/Silk.NET.WebGPU/Structs/RequiredLimits.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RequiredLimits.gen.cs index 77a07114f9..fbf13c25b9 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/RequiredLimits.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RequiredLimits.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPURequiredLimits")] public unsafe partial struct RequiredLimits diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleSPIRVDescriptor.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ShaderModuleSPIRVDescriptor.gen.cs similarity index 97% rename from src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleSPIRVDescriptor.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ShaderModuleSPIRVDescriptor.gen.cs index ea01841ede..462836c57e 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleSPIRVDescriptor.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ShaderModuleSPIRVDescriptor.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUShaderModuleSPIRVDescriptor")] public unsafe partial struct ShaderModuleSPIRVDescriptor diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleWGSLDescriptor.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ShaderModuleWGSLDescriptor.gen.cs similarity index 96% rename from src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleWGSLDescriptor.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ShaderModuleWGSLDescriptor.gen.cs index 440a8ecf78..53826338ff 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleWGSLDescriptor.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/ShaderModuleWGSLDescriptor.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUShaderModuleWGSLDescriptor")] public unsafe partial struct ShaderModuleWGSLDescriptor diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SupportedLimits.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SupportedLimits.gen.cs similarity index 96% rename from src/WebGPU/Silk.NET.WebGPU/Structs/SupportedLimits.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SupportedLimits.gen.cs index 58605b4e03..25f98fc4fc 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SupportedLimits.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SupportedLimits.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUSupportedLimits")] public unsafe partial struct SupportedLimits diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromAndroidNativeWindow.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromAndroidNativeWindow.gen.cs similarity index 96% rename from src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromAndroidNativeWindow.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromAndroidNativeWindow.gen.cs index a510579de4..ab7d757cab 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromAndroidNativeWindow.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromAndroidNativeWindow.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUSurfaceDescriptorFromAndroidNativeWindow")] public unsafe partial struct SurfaceDescriptorFromAndroidNativeWindow diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromCanvasHTMLSelector.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromCanvasHTMLSelector.gen.cs similarity index 96% rename from src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromCanvasHTMLSelector.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromCanvasHTMLSelector.gen.cs index a1472202d2..f297706f69 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromCanvasHTMLSelector.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromCanvasHTMLSelector.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUSurfaceDescriptorFromCanvasHTMLSelector")] public unsafe partial struct SurfaceDescriptorFromCanvasHTMLSelector diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromMetalLayer.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromMetalLayer.gen.cs similarity index 96% rename from src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromMetalLayer.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromMetalLayer.gen.cs index 566434da23..a66e8f4206 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromMetalLayer.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromMetalLayer.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUSurfaceDescriptorFromMetalLayer")] public unsafe partial struct SurfaceDescriptorFromMetalLayer diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromWaylandSurface.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromWaylandSurface.gen.cs similarity index 97% rename from src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromWaylandSurface.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromWaylandSurface.gen.cs index f7160b3eeb..37e84dfa6e 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromWaylandSurface.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromWaylandSurface.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUSurfaceDescriptorFromWaylandSurface")] public unsafe partial struct SurfaceDescriptorFromWaylandSurface diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromWindowsHWND.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromWindowsHWND.gen.cs similarity index 97% rename from src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromWindowsHWND.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromWindowsHWND.gen.cs index 2f022b444e..90c5c35b93 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromWindowsHWND.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromWindowsHWND.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUSurfaceDescriptorFromWindowsHWND")] public unsafe partial struct SurfaceDescriptorFromWindowsHWND diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromXlibWindow.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromXlibWindow.gen.cs similarity index 97% rename from src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromXlibWindow.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromXlibWindow.gen.cs index bea0d7f956..1b2bca90de 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromXlibWindow.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/SurfaceDescriptorFromXlibWindow.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUSurfaceDescriptorFromXlibWindow")] public unsafe partial struct SurfaceDescriptorFromXlibWindow diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/TextureDataLayout.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/TextureDataLayout.gen.cs similarity index 97% rename from src/WebGPU/Silk.NET.WebGPU/Structs/TextureDataLayout.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/TextureDataLayout.gen.cs index 50faf95aa7..fb143b4971 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/TextureDataLayout.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/TextureDataLayout.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU +namespace Silk.NET.WebGPU.Extensions.Dawn { [NativeName("Name", "WGPUTextureDataLayout")] public unsafe partial struct TextureDataLayout diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/DxcMaxShaderModel.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/DxcMaxShaderModel.gen.cs new file mode 100644 index 0000000000..56b9fe96d6 --- /dev/null +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/DxcMaxShaderModel.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU.Extensions.WGPU +{ + [NativeName("Name", "WGPUDxcMaxShaderModel")] + public enum DxcMaxShaderModel : int + { + [NativeName("Name", "WGPUDxcMaxShaderModel_V6_0")] + V60 = 0x0, + [NativeName("Name", "WGPUDxcMaxShaderModel_V6_1")] + V61 = 0x1, + [NativeName("Name", "WGPUDxcMaxShaderModel_V6_2")] + V62 = 0x2, + [NativeName("Name", "WGPUDxcMaxShaderModel_V6_3")] + V63 = 0x3, + [NativeName("Name", "WGPUDxcMaxShaderModel_V6_4")] + V64 = 0x4, + [NativeName("Name", "WGPUDxcMaxShaderModel_V6_5")] + V65 = 0x5, + [NativeName("Name", "WGPUDxcMaxShaderModel_V6_6")] + V66 = 0x6, + [NativeName("Name", "WGPUDxcMaxShaderModel_V6_7")] + V67 = 0x7, + [NativeName("Name", "WGPUDxcMaxShaderModel_Force32")] + Force32 = 0x7FFFFFFF, + } +} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/GLFenceBehaviour.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/GLFenceBehaviour.gen.cs new file mode 100644 index 0000000000..06b9971d37 --- /dev/null +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/GLFenceBehaviour.gen.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU.Extensions.WGPU +{ + [NativeName("Name", "WGPUGLFenceBehaviour")] + public enum GLFenceBehaviour : int + { + [NativeName("Name", "WGPUGLFenceBehaviour_Normal")] + Normal = 0x0, + [NativeName("Name", "WGPUGLFenceBehaviour_AutoFinish")] + AutoFinish = 0x1, + [NativeName("Name", "WGPUGLFenceBehaviour_Force32")] + Force32 = 0x7FFFFFFF, + } +} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/InstanceBackend.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/InstanceBackend.gen.cs deleted file mode 100644 index 2d60071555..0000000000 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/InstanceBackend.gen.cs +++ /dev/null @@ -1,37 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using Silk.NET.Core.Attributes; - -#pragma warning disable 1591 - -namespace Silk.NET.WebGPU.Extensions.WGPU -{ - [Flags] - [NativeName("Name", "WGPUInstanceBackend")] - public enum InstanceBackend : int - { - [NativeName("Name", "WGPUInstanceBackend_All")] - All = 0x0, - [NativeName("Name", "WGPUInstanceBackend_Vulkan")] - Vulkan = 0x1, - [NativeName("Name", "WGPUInstanceBackend_GL")] - GL = 0x2, - [NativeName("Name", "WGPUInstanceBackend_Metal")] - Metal = 0x4, - [NativeName("Name", "WGPUInstanceBackend_DX12")] - DX12 = 0x8, - [NativeName("Name", "WGPUInstanceBackend_DX11")] - DX11 = 0x10, - [NativeName("Name", "WGPUInstanceBackend_BrowserWebGPU")] - BrowserWebGpu = 0x20, - [NativeName("Name", "WGPUInstanceBackend_Primary")] - Primary = 0x2D, - [NativeName("Name", "WGPUInstanceBackend_Secondary")] - Secondary = 0x12, - [NativeName("Name", "WGPUInstanceBackend_Force32")] - Force32 = 0x7FFFFFFF, - } -} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/InstanceFlag.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/InstanceFlag.gen.cs deleted file mode 100644 index 7de1070d9d..0000000000 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/InstanceFlag.gen.cs +++ /dev/null @@ -1,27 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using Silk.NET.Core.Attributes; - -#pragma warning disable 1591 - -namespace Silk.NET.WebGPU.Extensions.WGPU -{ - [Flags] - [NativeName("Name", "WGPUInstanceFlag")] - public enum InstanceFlag : int - { - [NativeName("Name", "WGPUInstanceFlag_Default")] - Default = 0x0, - [NativeName("Name", "WGPUInstanceFlag_Debug")] - Debug = 0x1, - [NativeName("Name", "WGPUInstanceFlag_Validation")] - Validation = 0x2, - [NativeName("Name", "WGPUInstanceFlag_DiscardHalLabels")] - DiscardHalLabels = 0x4, - [NativeName("Name", "WGPUInstanceFlag_Force32")] - Force32 = 0x7FFFFFFF, - } -} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeFeature.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeFeature.gen.cs index c0af79a6ee..9d38ad4861 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeFeature.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeFeature.gen.cs @@ -42,24 +42,36 @@ public enum NativeFeature : int BufferBindingArray = 0x3000F, [NativeName("Name", "WGPUNativeFeature_UniformBufferAndStorageTextureArrayNonUniformIndexing")] UniformBufferAndStorageTextureArrayNonUniformIndexing = 0x30010, + [NativeName("Name", "WGPUNativeFeature_SpirvShaderPassthrough")] + SpirvShaderPassthrough = 0x30017, [NativeName("Name", "WGPUNativeFeature_VertexAttribute64bit")] VertexAttribute64bit = 0x30019, - [NativeName("Name", "WGPUNativeFeature_ShaderUnusedVertexOutput")] - ShaderUnusedVertexOutput = 0x3001A, [NativeName("Name", "WGPUNativeFeature_TextureFormatNv12")] - TextureFormatNv12 = 0x3001B, + TextureFormatNv12 = 0x3001A, [NativeName("Name", "WGPUNativeFeature_RayTracingAccelerationStructure")] - RayTracingAccelerationStructure = 0x3001C, + RayTracingAccelerationStructure = 0x3001B, [NativeName("Name", "WGPUNativeFeature_RayQuery")] - RayQuery = 0x3001D, + RayQuery = 0x3001C, [NativeName("Name", "WGPUNativeFeature_ShaderF64")] - ShaderF64 = 0x3001E, + ShaderF64 = 0x3001D, [NativeName("Name", "WGPUNativeFeature_ShaderI16")] - ShaderI16 = 0x3001F, + ShaderI16 = 0x3001E, [NativeName("Name", "WGPUNativeFeature_ShaderPrimitiveIndex")] - ShaderPrimitiveIndex = 0x30020, + ShaderPrimitiveIndex = 0x3001F, [NativeName("Name", "WGPUNativeFeature_ShaderEarlyDepthTest")] - ShaderEarlyDepthTest = 0x30021, + ShaderEarlyDepthTest = 0x30020, + [NativeName("Name", "WGPUNativeFeature_Subgroup")] + Subgroup = 0x30021, + [NativeName("Name", "WGPUNativeFeature_SubgroupVertex")] + SubgroupVertex = 0x30022, + [NativeName("Name", "WGPUNativeFeature_SubgroupBarrier")] + SubgroupBarrier = 0x30023, + [NativeName("Name", "WGPUNativeFeature_TimestampQueryInsideEncoders")] + TimestampQueryInsideEncoders = 0x30024, + [NativeName("Name", "WGPUNativeFeature_TimestampQueryInsidePasses")] + TimestampQueryInsidePasses = 0x30025, + [NativeName("Name", "WGPUNativeFeature_ShaderInt64")] + ShaderInt64 = 0x30026, [NativeName("Name", "WGPUNativeFeature_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeSType.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeSType.gen.cs index 919eff3e8e..45748baf2c 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeSType.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeSType.gen.cs @@ -14,14 +14,12 @@ public enum NativeSType : int { [NativeName("Name", "WGPUSType_DeviceExtras")] STypeDeviceExtras = 0x30001, - [NativeName("Name", "WGPUSType_RequiredLimitsExtras")] - STypeRequiredLimitsExtras = 0x30002, + [NativeName("Name", "WGPUSType_NativeLimits")] + STypeNativeLimits = 0x30002, [NativeName("Name", "WGPUSType_PipelineLayoutExtras")] STypePipelineLayoutExtras = 0x30003, - [NativeName("Name", "WGPUSType_ShaderModuleGLSLDescriptor")] - STypeShaderModuleGlsldescriptor = 0x30004, - [NativeName("Name", "WGPUSType_SupportedLimitsExtras")] - STypeSupportedLimitsExtras = 0x30005, + [NativeName("Name", "WGPUSType_ShaderSourceGLSL")] + STypeShaderSourceGlsl = 0x30004, [NativeName("Name", "WGPUSType_InstanceExtras")] STypeInstanceExtras = 0x30006, [NativeName("Name", "WGPUSType_BindGroupEntryExtras")] @@ -32,6 +30,8 @@ public enum NativeSType : int STypeQuerySetDescriptorExtras = 0x30009, [NativeName("Name", "WGPUSType_SurfaceConfigurationExtras")] STypeSurfaceConfigurationExtras = 0x3000A, + [NativeName("Name", "WGPUSType_SurfaceSourceSwapChainPanel")] + STypeSurfaceSourceSwapChainPanel = 0x3000B, [NativeName("Name", "WGPUNativeSType_Force32")] NativeSTypeForce32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeTextureFormat.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeTextureFormat.gen.cs new file mode 100644 index 0000000000..0903c9b4d0 --- /dev/null +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Enums/NativeTextureFormat.gen.cs @@ -0,0 +1,30 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU.Extensions.WGPU +{ + [NativeName("Name", "WGPUNativeTextureFormat")] + public enum NativeTextureFormat : int + { + [NativeName("Name", "WGPUNativeTextureFormat_R16Unorm")] + R16Unorm = 0x30001, + [NativeName("Name", "WGPUNativeTextureFormat_R16Snorm")] + R16Snorm = 0x30002, + [NativeName("Name", "WGPUNativeTextureFormat_Rg16Unorm")] + Rg16Unorm = 0x30003, + [NativeName("Name", "WGPUNativeTextureFormat_Rg16Snorm")] + Rg16Snorm = 0x30004, + [NativeName("Name", "WGPUNativeTextureFormat_Rgba16Unorm")] + Rgba16Unorm = 0x30005, + [NativeName("Name", "WGPUNativeTextureFormat_Rgba16Snorm")] + Rgba16Snorm = 0x30006, + [NativeName("Name", "WGPUNativeTextureFormat_NV12")] + NV12 = 0x30007, + } +} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/DeviceExtras.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/DeviceExtras.gen.cs index 992f011355..948d76ecd6 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/DeviceExtras.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/DeviceExtras.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct DeviceExtras public DeviceExtras ( ChainedStruct? chain = null, - byte* tracePath = null + StringView? tracePath = null ) : this() { if (chain is not null) @@ -32,7 +32,7 @@ public DeviceExtras if (tracePath is not null) { - TracePath = tracePath; + TracePath = tracePath.Value; } } @@ -42,9 +42,9 @@ public DeviceExtras [NativeName("Name", "chain")] public ChainedStruct Chain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "tracePath")] - public byte* TracePath; + public StringView TracePath; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/GlobalReport.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/GlobalReport.gen.cs index 799737b48c..1726fb9836 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/GlobalReport.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/GlobalReport.gen.cs @@ -22,11 +22,7 @@ public unsafe partial struct GlobalReport public GlobalReport ( RegistryReport? surfaces = null, - BackendType? backendType = null, - HubReport? vulkan = null, - HubReport? metal = null, - HubReport? dx12 = null, - HubReport? gl = null + HubReport? hub = null ) : this() { if (surfaces is not null) @@ -34,29 +30,9 @@ public GlobalReport Surfaces = surfaces.Value; } - if (backendType is not null) + if (hub is not null) { - BackendType = backendType.Value; - } - - if (vulkan is not null) - { - Vulkan = vulkan.Value; - } - - if (metal is not null) - { - Metal = metal.Value; - } - - if (dx12 is not null) - { - Dx12 = dx12.Value; - } - - if (gl is not null) - { - Gl = gl.Value; + Hub = hub.Value; } } @@ -66,29 +42,9 @@ public GlobalReport [NativeName("Name", "surfaces")] public RegistryReport Surfaces; - [NativeName("Type", "WGPUBackendType")] - [NativeName("Type.Name", "WGPUBackendType")] - [NativeName("Name", "backendType")] - public BackendType BackendType; - - [NativeName("Type", "WGPUHubReport")] - [NativeName("Type.Name", "WGPUHubReport")] - [NativeName("Name", "vulkan")] - public HubReport Vulkan; - - [NativeName("Type", "WGPUHubReport")] - [NativeName("Type.Name", "WGPUHubReport")] - [NativeName("Name", "metal")] - public HubReport Metal; - - [NativeName("Type", "WGPUHubReport")] - [NativeName("Type.Name", "WGPUHubReport")] - [NativeName("Name", "dx12")] - public HubReport Dx12; - [NativeName("Type", "WGPUHubReport")] [NativeName("Type.Name", "WGPUHubReport")] - [NativeName("Name", "gl")] - public HubReport Gl; + [NativeName("Name", "hub")] + public HubReport Hub; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/HubReport.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/HubReport.gen.cs index 8eddf0a38a..d8e5491e79 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/HubReport.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/HubReport.gen.cs @@ -32,6 +32,7 @@ public HubReport RegistryReport? renderBundles = null, RegistryReport? renderPipelines = null, RegistryReport? computePipelines = null, + RegistryReport? pipelineCaches = null, RegistryReport? querySets = null, RegistryReport? buffers = null, RegistryReport? textures = null, @@ -94,6 +95,11 @@ public HubReport ComputePipelines = computePipelines.Value; } + if (pipelineCaches is not null) + { + PipelineCaches = pipelineCaches.Value; + } + if (querySets is not null) { QuerySets = querySets.Value; @@ -176,6 +182,11 @@ public HubReport [NativeName("Name", "computePipelines")] public RegistryReport ComputePipelines; + [NativeName("Type", "WGPURegistryReport")] + [NativeName("Type.Name", "WGPURegistryReport")] + [NativeName("Name", "pipelineCaches")] + public RegistryReport PipelineCaches; + [NativeName("Type", "WGPURegistryReport")] [NativeName("Type.Name", "WGPURegistryReport")] [NativeName("Name", "querySets")] diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/InstanceEnumerateAdapterOptions.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/InstanceEnumerateAdapterOptions.gen.cs index 72fc8db6b3..1bd9aced5e 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/InstanceEnumerateAdapterOptions.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/InstanceEnumerateAdapterOptions.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct InstanceEnumerateAdapterOptions public InstanceEnumerateAdapterOptions ( ChainedStruct* nextInChain = null, - Silk.NET.WebGPU.Extensions.WGPU.InstanceBackend? backends = null + ulong? backends = null ) : this() { if (nextInChain is not null) @@ -42,9 +42,9 @@ public InstanceEnumerateAdapterOptions [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "WGPUInstanceBackendFlags")] - [NativeName("Type.Name", "WGPUInstanceBackendFlags")] + [NativeName("Type", "WGPUInstanceBackend")] + [NativeName("Type.Name", "WGPUInstanceBackend")] [NativeName("Name", "backends")] - public Silk.NET.WebGPU.Extensions.WGPU.InstanceBackend Backends; + public ulong Backends; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/InstanceExtras.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/InstanceExtras.gen.cs index 138551697e..02409bf059 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/InstanceExtras.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/InstanceExtras.gen.cs @@ -22,12 +22,14 @@ public unsafe partial struct InstanceExtras public InstanceExtras ( ChainedStruct? chain = null, - Silk.NET.WebGPU.Extensions.WGPU.InstanceBackend? backends = null, - uint? flags = null, + ulong? backends = null, + ulong? flags = null, Dx12Compiler? dx12ShaderCompiler = null, Gles3MinorVersion? gles3MinorVersion = null, - byte* dxilPath = null, - byte* dxcPath = null + GLFenceBehaviour? glFenceBehaviour = null, + StringView? dxilPath = null, + StringView? dxcPath = null, + DxcMaxShaderModel? dxcMaxShaderModel = null ) : this() { if (chain is not null) @@ -55,14 +57,24 @@ public InstanceExtras Gles3MinorVersion = gles3MinorVersion.Value; } + if (glFenceBehaviour is not null) + { + GlFenceBehaviour = glFenceBehaviour.Value; + } + if (dxilPath is not null) { - DxilPath = dxilPath; + DxilPath = dxilPath.Value; } if (dxcPath is not null) { - DxcPath = dxcPath; + DxcPath = dxcPath.Value; + } + + if (dxcMaxShaderModel is not null) + { + DxcMaxShaderModel = dxcMaxShaderModel.Value; } } @@ -72,15 +84,15 @@ public InstanceExtras [NativeName("Name", "chain")] public ChainedStruct Chain; - [NativeName("Type", "WGPUInstanceBackendFlags")] - [NativeName("Type.Name", "WGPUInstanceBackendFlags")] + [NativeName("Type", "WGPUInstanceBackend")] + [NativeName("Type.Name", "WGPUInstanceBackend")] [NativeName("Name", "backends")] - public Silk.NET.WebGPU.Extensions.WGPU.InstanceBackend Backends; + public ulong Backends; - [NativeName("Type", "WGPUInstanceFlags")] - [NativeName("Type.Name", "WGPUInstanceFlags")] + [NativeName("Type", "WGPUInstanceFlag")] + [NativeName("Type.Name", "WGPUInstanceFlag")] [NativeName("Name", "flags")] - public uint Flags; + public ulong Flags; [NativeName("Type", "WGPUDx12Compiler")] [NativeName("Type.Name", "WGPUDx12Compiler")] @@ -92,14 +104,24 @@ public InstanceExtras [NativeName("Name", "gles3MinorVersion")] public Gles3MinorVersion Gles3MinorVersion; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUGLFenceBehaviour")] + [NativeName("Type.Name", "WGPUGLFenceBehaviour")] + [NativeName("Name", "glFenceBehaviour")] + public GLFenceBehaviour GlFenceBehaviour; + + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "dxilPath")] - public byte* DxilPath; + public StringView DxilPath; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "dxcPath")] - public byte* DxcPath; + public StringView DxcPath; + + [NativeName("Type", "WGPUDxcMaxShaderModel")] + [NativeName("Type.Name", "WGPUDxcMaxShaderModel")] + [NativeName("Name", "dxcMaxShaderModel")] + public DxcMaxShaderModel DxcMaxShaderModel; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/NativeLimits.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/NativeLimits.gen.cs index 1c5eaf7496..f2b3b613dc 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/NativeLimits.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/NativeLimits.gen.cs @@ -21,10 +21,16 @@ public unsafe partial struct NativeLimits { public NativeLimits ( + WGPUChainedStructOut? chain = null, uint? maxPushConstantSize = null, uint? maxNonSamplerBindings = null ) : this() { + if (chain is not null) + { + Chain = chain.Value; + } + if (maxPushConstantSize is not null) { MaxPushConstantSize = maxPushConstantSize.Value; @@ -37,6 +43,11 @@ public NativeLimits } + [NativeName("Type", "WGPUChainedStructOut")] + [NativeName("Type.Name", "WGPUChainedStructOut")] + [NativeName("Name", "chain")] + public WGPUChainedStructOut Chain; + [NativeName("Type", "uint32_t")] [NativeName("Type.Name", "uint32_t")] [NativeName("Name", "maxPushConstantSize")] diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/PfnLogCallback.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/PfnLogCallback.gen.cs index dcebb8af27..432a3b3ceb 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/PfnLogCallback.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/PfnLogCallback.gen.cs @@ -19,10 +19,10 @@ namespace Silk.NET.WebGPU.Extensions.WGPU public unsafe readonly struct PfnLogCallback : IDisposable { private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; public PfnLogCallback ( - delegate* unmanaged[Cdecl] ptr + delegate* unmanaged[Cdecl] ptr ) => _handle = ptr; public PfnLogCallback @@ -35,7 +35,7 @@ LogCallback proc public static implicit operator nint(PfnLogCallback pfn) => (nint) pfn.Handle; public static explicit operator PfnLogCallback(nint pfn) - => new PfnLogCallback((delegate* unmanaged[Cdecl]) pfn); + => new PfnLogCallback((delegate* unmanaged[Cdecl]) pfn); public static implicit operator PfnLogCallback(LogCallback proc) => new PfnLogCallback(proc); @@ -43,11 +43,11 @@ public static implicit operator PfnLogCallback(LogCallback proc) public static explicit operator LogCallback(PfnLogCallback pfn) => SilkMarshal.PtrToDelegate(pfn); - public static implicit operator delegate* unmanaged[Cdecl](PfnLogCallback pfn) => pfn.Handle; - public static implicit operator PfnLogCallback(delegate* unmanaged[Cdecl] ptr) => new PfnLogCallback(ptr); + public static implicit operator delegate* unmanaged[Cdecl](PfnLogCallback pfn) => pfn.Handle; + public static implicit operator PfnLogCallback(delegate* unmanaged[Cdecl] ptr) => new PfnLogCallback(ptr); } [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate void LogCallback(LogLevel arg0, byte* arg1, void* arg2); + public unsafe delegate void LogCallback(LogLevel arg0, StringView arg1, void* arg2); } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/PushConstantRange.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/PushConstantRange.gen.cs index c22ea453c7..8d673d2905 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/PushConstantRange.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/PushConstantRange.gen.cs @@ -21,7 +21,7 @@ public unsafe partial struct PushConstantRange { public PushConstantRange ( - Silk.NET.WebGPU.ShaderStage? stages = null, + ulong? stages = null, uint? start = null, uint? end = null ) : this() @@ -43,10 +43,10 @@ public PushConstantRange } - [NativeName("Type", "WGPUShaderStageFlags")] - [NativeName("Type.Name", "WGPUShaderStageFlags")] + [NativeName("Type", "WGPUShaderStage")] + [NativeName("Type.Name", "WGPUShaderStage")] [NativeName("Name", "stages")] - public Silk.NET.WebGPU.ShaderStage Stages; + public ulong Stages; [NativeName("Type", "uint32_t")] [NativeName("Type.Name", "uint32_t")] diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/RegistryReport.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/RegistryReport.gen.cs index 8fc4d72365..1825766297 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/RegistryReport.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/RegistryReport.gen.cs @@ -24,7 +24,6 @@ public RegistryReport nuint? numAllocated = null, nuint? numKeptFromUser = null, nuint? numReleasedFromUser = null, - nuint? numError = null, nuint? elementSize = null ) : this() { @@ -43,11 +42,6 @@ public RegistryReport NumReleasedFromUser = numReleasedFromUser.Value; } - if (numError is not null) - { - NumError = numError.Value; - } - if (elementSize is not null) { ElementSize = elementSize.Value; @@ -70,11 +64,6 @@ public RegistryReport [NativeName("Name", "numReleasedFromUser")] public nuint NumReleasedFromUser; - [NativeName("Type", "size_t")] - [NativeName("Type.Name", "size_t")] - [NativeName("Name", "numError")] - public nuint NumError; - [NativeName("Type", "size_t")] [NativeName("Type.Name", "size_t")] [NativeName("Name", "elementSize")] diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderDefine.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderDefine.gen.cs index 0274941ca1..2322176230 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderDefine.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderDefine.gen.cs @@ -21,30 +21,30 @@ public unsafe partial struct ShaderDefine { public ShaderDefine ( - byte* name = null, - byte* value = null + StringView? name = null, + StringView? value = null ) : this() { if (name is not null) { - Name = name; + Name = name.Value; } if (value is not null) { - Value = value; + Value = value.Value; } } - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "name")] - public byte* Name; + public StringView Name; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "value")] - public byte* Value; + public StringView Value; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderModuleDescriptorSpirV.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderModuleDescriptorSpirV.gen.cs new file mode 100644 index 0000000000..5674ac3c49 --- /dev/null +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderModuleDescriptorSpirV.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU.Extensions.WGPU +{ + [NativeName("Name", "WGPUShaderModuleDescriptorSpirV")] + public unsafe partial struct ShaderModuleDescriptorSpirV + { + public ShaderModuleDescriptorSpirV + ( + StringView? label = null, + uint? sourceSize = null, + uint* source = null + ) : this() + { + if (label is not null) + { + Label = label.Value; + } + + if (sourceSize is not null) + { + SourceSize = sourceSize.Value; + } + + if (source is not null) + { + Source = source; + } + } + + + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] + [NativeName("Name", "label")] + public StringView Label; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "sourceSize")] + public uint SourceSize; + + [NativeName("Type", "const uint32_t *")] + [NativeName("Type.Name", "const uint32_t *")] + [NativeName("Name", "source")] + public uint* Source; + } +} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderModuleGLSLDescriptor.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderSourceGLSL.gen.cs similarity index 81% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderModuleGLSLDescriptor.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderSourceGLSL.gen.cs index e01f7717c3..0334a2bbf2 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderModuleGLSLDescriptor.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/ShaderSourceGLSL.gen.cs @@ -16,14 +16,14 @@ namespace Silk.NET.WebGPU.Extensions.WGPU { - [NativeName("Name", "WGPUShaderModuleGLSLDescriptor")] - public unsafe partial struct ShaderModuleGLSLDescriptor + [NativeName("Name", "WGPUShaderSourceGLSL")] + public unsafe partial struct ShaderSourceGLSL { - public ShaderModuleGLSLDescriptor + public ShaderSourceGLSL ( ChainedStruct? chain = null, - ShaderStage? stage = null, - byte* code = null, + ulong? stage = null, + StringView? code = null, uint? defineCount = null, ShaderDefine* defines = null ) : this() @@ -40,7 +40,7 @@ public ShaderModuleGLSLDescriptor if (code is not null) { - Code = code; + Code = code.Value; } if (defineCount is not null) @@ -63,12 +63,12 @@ public ShaderModuleGLSLDescriptor [NativeName("Type", "WGPUShaderStage")] [NativeName("Type.Name", "WGPUShaderStage")] [NativeName("Name", "stage")] - public ShaderStage Stage; + public ulong Stage; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "code")] - public byte* Code; + public StringView Code; [NativeName("Type", "uint32_t")] [NativeName("Type.Name", "uint32_t")] diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/SupportedLimitsExtras.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/SupportedLimitsExtras.gen.cs deleted file mode 100644 index 676d1758a5..0000000000 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/SupportedLimitsExtras.gen.cs +++ /dev/null @@ -1,50 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using System.Runtime.InteropServices; -using System.Runtime.CompilerServices; -using System.Text; -using Silk.NET.Core; -using Silk.NET.Core.Native; -using Silk.NET.Core.Attributes; -using Silk.NET.Core.Contexts; -using Silk.NET.Core.Loader; - -#pragma warning disable 1591 - -namespace Silk.NET.WebGPU.Extensions.WGPU -{ - [NativeName("Name", "WGPUSupportedLimitsExtras")] - public unsafe partial struct SupportedLimitsExtras - { - public SupportedLimitsExtras - ( - ChainedStructOut? chain = null, - NativeLimits? limits = null - ) : this() - { - if (chain is not null) - { - Chain = chain.Value; - } - - if (limits is not null) - { - Limits = limits.Value; - } - } - - - [NativeName("Type", "WGPUChainedStructOut")] - [NativeName("Type.Name", "WGPUChainedStructOut")] - [NativeName("Name", "chain")] - public ChainedStructOut Chain; - - [NativeName("Type", "WGPUNativeLimits")] - [NativeName("Type.Name", "WGPUNativeLimits")] - [NativeName("Name", "limits")] - public NativeLimits Limits; - } -} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/SurfaceConfigurationExtras.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/SurfaceConfigurationExtras.gen.cs index 429fa826dc..ca8d5f68c4 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/SurfaceConfigurationExtras.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/SurfaceConfigurationExtras.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct SurfaceConfigurationExtras public SurfaceConfigurationExtras ( ChainedStruct? chain = null, - Silk.NET.Core.Bool32? desiredMaximumFrameLatency = null + uint? desiredMaximumFrameLatency = null ) : this() { if (chain is not null) @@ -42,9 +42,9 @@ public SurfaceConfigurationExtras [NativeName("Name", "chain")] public ChainedStruct Chain; - [NativeName("Type", "WGPUBool")] - [NativeName("Type.Name", "WGPUBool")] + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] [NativeName("Name", "desiredMaximumFrameLatency")] - public Silk.NET.Core.Bool32 DesiredMaximumFrameLatency; + public uint DesiredMaximumFrameLatency; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/RequiredLimitsExtras.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/SurfaceSourceSwapChainPanel.gen.cs similarity index 66% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/RequiredLimitsExtras.gen.cs rename to src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/SurfaceSourceSwapChainPanel.gen.cs index 7b316deac5..a1ff81f56d 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/RequiredLimitsExtras.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/SurfaceSourceSwapChainPanel.gen.cs @@ -16,13 +16,13 @@ namespace Silk.NET.WebGPU.Extensions.WGPU { - [NativeName("Name", "WGPURequiredLimitsExtras")] - public unsafe partial struct RequiredLimitsExtras + [NativeName("Name", "WGPUSurfaceSourceSwapChainPanel")] + public unsafe partial struct SurfaceSourceSwapChainPanel { - public RequiredLimitsExtras + public SurfaceSourceSwapChainPanel ( ChainedStruct? chain = null, - NativeLimits? limits = null + void* panelNative = null ) : this() { if (chain is not null) @@ -30,9 +30,9 @@ public RequiredLimitsExtras Chain = chain.Value; } - if (limits is not null) + if (panelNative is not null) { - Limits = limits.Value; + PanelNative = panelNative; } } @@ -42,9 +42,9 @@ public RequiredLimitsExtras [NativeName("Name", "chain")] public ChainedStruct Chain; - [NativeName("Type", "WGPUNativeLimits")] - [NativeName("Type.Name", "WGPUNativeLimits")] - [NativeName("Name", "limits")] - public NativeLimits Limits; + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "panelNative")] + public void* PanelNative; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/WrappedSubmissionIndex.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/WrappedSubmissionIndex.gen.cs deleted file mode 100644 index 5c4d78a5f6..0000000000 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Structs/WrappedSubmissionIndex.gen.cs +++ /dev/null @@ -1,50 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using System.Runtime.InteropServices; -using System.Runtime.CompilerServices; -using System.Text; -using Silk.NET.Core; -using Silk.NET.Core.Native; -using Silk.NET.Core.Attributes; -using Silk.NET.Core.Contexts; -using Silk.NET.Core.Loader; - -#pragma warning disable 1591 - -namespace Silk.NET.WebGPU.Extensions.WGPU -{ - [NativeName("Name", "WGPUWrappedSubmissionIndex")] - public unsafe partial struct WrappedSubmissionIndex - { - public WrappedSubmissionIndex - ( - Queue* queue = null, - ulong? submissionIndex = null - ) : this() - { - if (queue is not null) - { - Queue = queue; - } - - if (submissionIndex is not null) - { - SubmissionIndex = submissionIndex.Value; - } - } - - - [NativeName("Type", "WGPUQueue")] - [NativeName("Type.Name", "WGPUQueue")] - [NativeName("Name", "queue")] - public Queue* Queue; - - [NativeName("Type", "WGPUSubmissionIndex")] - [NativeName("Type.Name", "WGPUSubmissionIndex")] - [NativeName("Name", "submissionIndex")] - public ulong SubmissionIndex; - } -} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Wgpu.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Wgpu.gen.cs index 400b6cbba6..0376959c5d 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Wgpu.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/Wgpu.gen.cs @@ -21,125 +21,165 @@ public unsafe partial class Wgpu : NativeExtension { public const string ExtensionName = "wgpu.h"; /// To be documented. - [NativeName("Src", "Line 259, Column 6 in wgpu.h")] + [NativeName("Src", "Line 291, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuGenerateReport")] public unsafe partial void GenerateReport(Instance* instance, GlobalReport* report); /// To be documented. - [NativeName("Src", "Line 259, Column 6 in wgpu.h")] + [NativeName("Src", "Line 291, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuGenerateReport")] public unsafe partial void GenerateReport(Instance* instance, ref GlobalReport report); /// To be documented. - [NativeName("Src", "Line 260, Column 8 in wgpu.h")] + [NativeName("Src", "Line 292, Column 8 in wgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceEnumerateAdapters")] public unsafe partial nuint InstanceEnumerateAdapters(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] InstanceEnumerateAdapterOptions* options, Adapter** adapters); /// To be documented. - [NativeName("Src", "Line 260, Column 8 in wgpu.h")] + [NativeName("Src", "Line 292, Column 8 in wgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceEnumerateAdapters")] public unsafe partial nuint InstanceEnumerateAdapters(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] InstanceEnumerateAdapterOptions* options, ref Adapter* adapters); /// To be documented. - [NativeName("Src", "Line 260, Column 8 in wgpu.h")] + [NativeName("Src", "Line 292, Column 8 in wgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceEnumerateAdapters")] public unsafe partial nuint InstanceEnumerateAdapters(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly InstanceEnumerateAdapterOptions options, Adapter** adapters); /// To be documented. - [NativeName("Src", "Line 260, Column 8 in wgpu.h")] + [NativeName("Src", "Line 292, Column 8 in wgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceEnumerateAdapters")] public unsafe partial nuint InstanceEnumerateAdapters(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly InstanceEnumerateAdapterOptions options, ref Adapter* adapters); /// To be documented. - [NativeName("Src", "Line 262, Column 21 in wgpu.h")] + [NativeName("Src", "Line 294, Column 21 in wgpu.h")] [NativeApi(EntryPoint = "wgpuQueueSubmitForIndex")] public unsafe partial ulong QueueSubmitForIndex(Queue* queue, nuint commandCount, CommandBuffer** commands); /// To be documented. - [NativeName("Src", "Line 262, Column 21 in wgpu.h")] + [NativeName("Src", "Line 294, Column 21 in wgpu.h")] [NativeApi(EntryPoint = "wgpuQueueSubmitForIndex")] public unsafe partial ulong QueueSubmitForIndex(Queue* queue, nuint commandCount, ref CommandBuffer* commands); /// To be documented. - [NativeName("Src", "Line 265, Column 10 in wgpu.h")] + [NativeName("Src", "Line 297, Column 10 in wgpu.h")] [NativeApi(EntryPoint = "wgpuDevicePoll")] - public unsafe partial Silk.NET.Core.Bool32 DevicePoll(Device* device, Silk.NET.Core.Bool32 wait, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WrappedSubmissionIndex* wrappedSubmissionIndex); + public unsafe partial Silk.NET.Core.Bool32 DevicePoll(Device* device, Silk.NET.Core.Bool32 wait, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong* submissionIndex); /// To be documented. - [NativeName("Src", "Line 265, Column 10 in wgpu.h")] + [NativeName("Src", "Line 297, Column 10 in wgpu.h")] [NativeApi(EntryPoint = "wgpuDevicePoll")] - public unsafe partial Silk.NET.Core.Bool32 DevicePoll(Device* device, Silk.NET.Core.Bool32 wait, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly WrappedSubmissionIndex wrappedSubmissionIndex); + public unsafe partial Silk.NET.Core.Bool32 DevicePoll(Device* device, Silk.NET.Core.Bool32 wait, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ulong submissionIndex); /// To be documented. - [NativeName("Src", "Line 267, Column 6 in wgpu.h")] + [NativeName("Src", "Line 298, Column 18 in wgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceCreateShaderModuleSpirV")] + public unsafe partial ShaderModule* DeviceCreateShaderModuleSpirV(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ShaderModuleDescriptorSpirV* descriptor); + + /// To be documented. + [NativeName("Src", "Line 298, Column 18 in wgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceCreateShaderModuleSpirV")] + public unsafe partial ShaderModule* DeviceCreateShaderModuleSpirV(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ShaderModuleDescriptorSpirV descriptor); + + /// To be documented. + [NativeName("Src", "Line 300, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuSetLogCallback")] public unsafe partial void SetLogCallback(PfnLogCallback callback, void* userdata); /// To be documented. - [NativeName("Src", "Line 267, Column 6 in wgpu.h")] + [NativeName("Src", "Line 300, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuSetLogCallback")] public partial void SetLogCallback(PfnLogCallback callback, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 269, Column 6 in wgpu.h")] + [NativeName("Src", "Line 302, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuSetLogLevel")] public partial void SetLogLevel(LogLevel level); /// To be documented. - [NativeName("Src", "Line 271, Column 10 in wgpu.h")] + [NativeName("Src", "Line 304, Column 10 in wgpu.h")] [NativeApi(EntryPoint = "wgpuGetVersion")] public partial uint GetVersion(); /// To be documented. - [NativeName("Src", "Line 273, Column 6 in wgpu.h")] + [NativeName("Src", "Line 306, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetPushConstants")] - public unsafe partial void RenderPassEncoderSetPushConstants(RenderPassEncoder* encoder, Silk.NET.WebGPU.ShaderStage stages, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data); + public unsafe partial void RenderPassEncoderSetPushConstants(RenderPassEncoder* encoder, ulong stages, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data); /// To be documented. - [NativeName("Src", "Line 273, Column 6 in wgpu.h")] + [NativeName("Src", "Line 306, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetPushConstants")] - public unsafe partial void RenderPassEncoderSetPushConstants(RenderPassEncoder* encoder, Silk.NET.WebGPU.ShaderStage stages, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data) where T0 : unmanaged; + public unsafe partial void RenderPassEncoderSetPushConstants(RenderPassEncoder* encoder, ulong stages, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 307, Column 6 in wgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderSetPushConstants")] + public unsafe partial void ComputePassEncoderSetPushConstants(ComputePassEncoder* encoder, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data); + + /// To be documented. + [NativeName("Src", "Line 307, Column 6 in wgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderSetPushConstants")] + public unsafe partial void ComputePassEncoderSetPushConstants(ComputePassEncoder* encoder, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 275, Column 6 in wgpu.h")] + [NativeName("Src", "Line 308, Column 6 in wgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetPushConstants")] + public unsafe partial void RenderBundleEncoderSetPushConstants(RenderBundleEncoder* encoder, ulong stages, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data); + + /// To be documented. + [NativeName("Src", "Line 308, Column 6 in wgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetPushConstants")] + public unsafe partial void RenderBundleEncoderSetPushConstants(RenderBundleEncoder* encoder, ulong stages, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 310, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderMultiDrawIndirect")] public unsafe partial void RenderPassEncoderMultiDrawIndirect(RenderPassEncoder* encoder, Buffer* buffer, ulong offset, uint count); /// To be documented. - [NativeName("Src", "Line 276, Column 6 in wgpu.h")] + [NativeName("Src", "Line 311, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderMultiDrawIndexedIndirect")] public unsafe partial void RenderPassEncoderMultiDrawIndexedIndirect(RenderPassEncoder* encoder, Buffer* buffer, ulong offset, uint count); /// To be documented. - [NativeName("Src", "Line 278, Column 6 in wgpu.h")] + [NativeName("Src", "Line 313, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderMultiDrawIndirectCount")] public unsafe partial void RenderPassEncoderMultiDrawIndirectCount(RenderPassEncoder* encoder, Buffer* buffer, ulong offset, Buffer* count_buffer, ulong count_buffer_offset, uint max_count); /// To be documented. - [NativeName("Src", "Line 279, Column 6 in wgpu.h")] + [NativeName("Src", "Line 314, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderMultiDrawIndexedIndirectCount")] public unsafe partial void RenderPassEncoderMultiDrawIndexedIndirectCount(RenderPassEncoder* encoder, Buffer* buffer, ulong offset, Buffer* count_buffer, ulong count_buffer_offset, uint max_count); /// To be documented. - [NativeName("Src", "Line 281, Column 6 in wgpu.h")] + [NativeName("Src", "Line 316, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderBeginPipelineStatisticsQuery")] public unsafe partial void ComputePassEncoderBeginPipelineStatisticsQuery(ComputePassEncoder* computePassEncoder, QuerySet* querySet, uint queryIndex); /// To be documented. - [NativeName("Src", "Line 282, Column 6 in wgpu.h")] + [NativeName("Src", "Line 317, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderEndPipelineStatisticsQuery")] public unsafe partial void ComputePassEncoderEndPipelineStatisticsQuery(ComputePassEncoder* computePassEncoder); /// To be documented. - [NativeName("Src", "Line 283, Column 6 in wgpu.h")] + [NativeName("Src", "Line 318, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderBeginPipelineStatisticsQuery")] public unsafe partial void RenderPassEncoderBeginPipelineStatisticsQuery(RenderPassEncoder* renderPassEncoder, QuerySet* querySet, uint queryIndex); /// To be documented. - [NativeName("Src", "Line 284, Column 6 in wgpu.h")] + [NativeName("Src", "Line 319, Column 6 in wgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderEndPipelineStatisticsQuery")] public unsafe partial void RenderPassEncoderEndPipelineStatisticsQuery(RenderPassEncoder* renderPassEncoder); + /// To be documented. + [NativeName("Src", "Line 321, Column 6 in wgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderWriteTimestamp")] + public unsafe partial void ComputePassEncoderWriteTimestamp(ComputePassEncoder* computePassEncoder, QuerySet* querySet, uint queryIndex); + + /// To be documented. + [NativeName("Src", "Line 322, Column 6 in wgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPassEncoderWriteTimestamp")] + public unsafe partial void RenderPassEncoderWriteTimestamp(RenderPassEncoder* renderPassEncoder, QuerySet* querySet, uint queryIndex); + public Wgpu(INativeContext ctx) : base(ctx) { diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/WgpuOverloads.gen.cs b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/WgpuOverloads.gen.cs index e4d8a9c75b..3155c4665f 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/WgpuOverloads.gen.cs +++ b/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.WGPU/WgpuOverloads.gen.cs @@ -17,7 +17,7 @@ namespace Silk.NET.WebGPU.Extensions.WGPU public static class WgpuOverloads { /// To be documented. - [NativeName("Src", "Line 259, Column 6 in wgpu.h")] + [NativeName("Src", "Line 291, Column 6 in wgpu.h")] public static unsafe void GenerateReport(this Wgpu thisApi, Instance* instance, Span report) { // SpanOverloader @@ -25,7 +25,7 @@ public static unsafe void GenerateReport(this Wgpu thisApi, Instance* instance, } /// To be documented. - [NativeName("Src", "Line 260, Column 8 in wgpu.h")] + [NativeName("Src", "Line 292, Column 8 in wgpu.h")] public static unsafe nuint InstanceEnumerateAdapters(this Wgpu thisApi, Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan options, Adapter** adapters) { // SpanOverloader @@ -33,7 +33,7 @@ public static unsafe nuint InstanceEnumerateAdapters(this Wgpu thisApi, Instance } /// To be documented. - [NativeName("Src", "Line 260, Column 8 in wgpu.h")] + [NativeName("Src", "Line 292, Column 8 in wgpu.h")] public static unsafe nuint InstanceEnumerateAdapters(this Wgpu thisApi, Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan options, ref Adapter* adapters) { // SpanOverloader @@ -41,15 +41,23 @@ public static unsafe nuint InstanceEnumerateAdapters(this Wgpu thisApi, Instance } /// To be documented. - [NativeName("Src", "Line 265, Column 10 in wgpu.h")] - public static unsafe Silk.NET.Core.Bool32 DevicePoll(this Wgpu thisApi, Device* device, Silk.NET.Core.Bool32 wait, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wrappedSubmissionIndex) + [NativeName("Src", "Line 297, Column 10 in wgpu.h")] + public static unsafe Silk.NET.Core.Bool32 DevicePoll(this Wgpu thisApi, Device* device, Silk.NET.Core.Bool32 wait, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan submissionIndex) { // SpanOverloader - return thisApi.DevicePoll(device, wait, in wrappedSubmissionIndex.GetPinnableReference()); + return thisApi.DevicePoll(device, wait, in submissionIndex.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 267, Column 6 in wgpu.h")] + [NativeName("Src", "Line 298, Column 18 in wgpu.h")] + public static unsafe ShaderModule* DeviceCreateShaderModuleSpirV(this Wgpu thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) + { + // SpanOverloader + return thisApi.DeviceCreateShaderModuleSpirV(device, in descriptor.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 300, Column 6 in wgpu.h")] public static unsafe void SetLogCallback(this Wgpu thisApi, PfnLogCallback callback, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -57,13 +65,29 @@ public static unsafe void SetLogCallback(this Wgpu thisApi, PfnLogCallback c } /// To be documented. - [NativeName("Src", "Line 273, Column 6 in wgpu.h")] - public static unsafe void RenderPassEncoderSetPushConstants(this Wgpu thisApi, RenderPassEncoder* encoder, Silk.NET.WebGPU.ShaderStage stages, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data) where T0 : unmanaged + [NativeName("Src", "Line 306, Column 6 in wgpu.h")] + public static unsafe void RenderPassEncoderSetPushConstants(this Wgpu thisApi, RenderPassEncoder* encoder, ulong stages, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data) where T0 : unmanaged { // SpanOverloader thisApi.RenderPassEncoderSetPushConstants(encoder, stages, offset, sizeBytes, in data.GetPinnableReference()); } + /// To be documented. + [NativeName("Src", "Line 307, Column 6 in wgpu.h")] + public static unsafe void ComputePassEncoderSetPushConstants(this Wgpu thisApi, ComputePassEncoder* encoder, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data) where T0 : unmanaged + { + // SpanOverloader + thisApi.ComputePassEncoderSetPushConstants(encoder, offset, sizeBytes, in data.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 308, Column 6 in wgpu.h")] + public static unsafe void RenderBundleEncoderSetPushConstants(this Wgpu thisApi, RenderBundleEncoder* encoder, ulong stages, uint offset, uint sizeBytes, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data) where T0 : unmanaged + { + // SpanOverloader + thisApi.RenderBundleEncoderSetPushConstants(encoder, stages, offset, sizeBytes, in data.GetPinnableReference()); + } + } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/AdapterType.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/AdapterType.gen.cs index cc30bed87c..ddff0257d0 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/AdapterType.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/AdapterType.gen.cs @@ -13,13 +13,13 @@ namespace Silk.NET.WebGPU public enum AdapterType : int { [NativeName("Name", "WGPUAdapterType_DiscreteGPU")] - DiscreteGpu = 0x0, + DiscreteGpu = 0x1, [NativeName("Name", "WGPUAdapterType_IntegratedGPU")] - IntegratedGpu = 0x1, + IntegratedGpu = 0x2, [NativeName("Name", "WGPUAdapterType_CPU")] - Cpu = 0x2, + Cpu = 0x3, [NativeName("Name", "WGPUAdapterType_Unknown")] - Unknown = 0x3, + Unknown = 0x4, [NativeName("Name", "WGPUAdapterType_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/AddressMode.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/AddressMode.gen.cs index edd5d15553..bd194f7159 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/AddressMode.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/AddressMode.gen.cs @@ -12,12 +12,14 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUAddressMode")] public enum AddressMode : int { + [NativeName("Name", "WGPUAddressMode_Undefined")] + Undefined = 0x0, + [NativeName("Name", "WGPUAddressMode_ClampToEdge")] + ClampToEdge = 0x1, [NativeName("Name", "WGPUAddressMode_Repeat")] - Repeat = 0x0, + Repeat = 0x2, [NativeName("Name", "WGPUAddressMode_MirrorRepeat")] - MirrorRepeat = 0x1, - [NativeName("Name", "WGPUAddressMode_ClampToEdge")] - ClampToEdge = 0x2, + MirrorRepeat = 0x3, [NativeName("Name", "WGPUAddressMode_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/BlendFactor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/BlendFactor.gen.cs index 05010e158b..bc8a5fdcbb 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/BlendFactor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/BlendFactor.gen.cs @@ -12,32 +12,42 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUBlendFactor")] public enum BlendFactor : int { + [NativeName("Name", "WGPUBlendFactor_Undefined")] + Undefined = 0x0, [NativeName("Name", "WGPUBlendFactor_Zero")] - Zero = 0x0, + Zero = 0x1, [NativeName("Name", "WGPUBlendFactor_One")] - One = 0x1, + One = 0x2, [NativeName("Name", "WGPUBlendFactor_Src")] - Src = 0x2, + Src = 0x3, [NativeName("Name", "WGPUBlendFactor_OneMinusSrc")] - OneMinusSrc = 0x3, + OneMinusSrc = 0x4, [NativeName("Name", "WGPUBlendFactor_SrcAlpha")] - SrcAlpha = 0x4, + SrcAlpha = 0x5, [NativeName("Name", "WGPUBlendFactor_OneMinusSrcAlpha")] - OneMinusSrcAlpha = 0x5, + OneMinusSrcAlpha = 0x6, [NativeName("Name", "WGPUBlendFactor_Dst")] - Dst = 0x6, + Dst = 0x7, [NativeName("Name", "WGPUBlendFactor_OneMinusDst")] - OneMinusDst = 0x7, + OneMinusDst = 0x8, [NativeName("Name", "WGPUBlendFactor_DstAlpha")] - DstAlpha = 0x8, + DstAlpha = 0x9, [NativeName("Name", "WGPUBlendFactor_OneMinusDstAlpha")] - OneMinusDstAlpha = 0x9, + OneMinusDstAlpha = 0xA, [NativeName("Name", "WGPUBlendFactor_SrcAlphaSaturated")] - SrcAlphaSaturated = 0xA, + SrcAlphaSaturated = 0xB, [NativeName("Name", "WGPUBlendFactor_Constant")] - Constant = 0xB, + Constant = 0xC, [NativeName("Name", "WGPUBlendFactor_OneMinusConstant")] - OneMinusConstant = 0xC, + OneMinusConstant = 0xD, + [NativeName("Name", "WGPUBlendFactor_Src1")] + Src1 = 0xE, + [NativeName("Name", "WGPUBlendFactor_OneMinusSrc1")] + OneMinusSrc1 = 0xF, + [NativeName("Name", "WGPUBlendFactor_Src1Alpha")] + Src1Alpha = 0x10, + [NativeName("Name", "WGPUBlendFactor_OneMinusSrc1Alpha")] + OneMinusSrc1Alpha = 0x11, [NativeName("Name", "WGPUBlendFactor_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/BlendOperation.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/BlendOperation.gen.cs index 5d5bcd7ad6..5d01a9421e 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/BlendOperation.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/BlendOperation.gen.cs @@ -12,16 +12,18 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUBlendOperation")] public enum BlendOperation : int { + [NativeName("Name", "WGPUBlendOperation_Undefined")] + Undefined = 0x0, [NativeName("Name", "WGPUBlendOperation_Add")] - Add = 0x0, + Add = 0x1, [NativeName("Name", "WGPUBlendOperation_Subtract")] - Subtract = 0x1, + Subtract = 0x2, [NativeName("Name", "WGPUBlendOperation_ReverseSubtract")] - ReverseSubtract = 0x2, + ReverseSubtract = 0x3, [NativeName("Name", "WGPUBlendOperation_Min")] - Min = 0x3, + Min = 0x4, [NativeName("Name", "WGPUBlendOperation_Max")] - Max = 0x4, + Max = 0x5, [NativeName("Name", "WGPUBlendOperation_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/BufferBindingType.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/BufferBindingType.gen.cs index 824240349f..2ef20b37e9 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/BufferBindingType.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/BufferBindingType.gen.cs @@ -12,14 +12,16 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUBufferBindingType")] public enum BufferBindingType : int { + [NativeName("Name", "WGPUBufferBindingType_BindingNotUsed")] + BindingNotUsed = 0x0, [NativeName("Name", "WGPUBufferBindingType_Undefined")] - Undefined = 0x0, + Undefined = 0x1, [NativeName("Name", "WGPUBufferBindingType_Uniform")] - Uniform = 0x1, + Uniform = 0x2, [NativeName("Name", "WGPUBufferBindingType_Storage")] - Storage = 0x2, + Storage = 0x3, [NativeName("Name", "WGPUBufferBindingType_ReadOnlyStorage")] - ReadOnlyStorage = 0x3, + ReadOnlyStorage = 0x4, [NativeName("Name", "WGPUBufferBindingType_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/BufferMapState.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/BufferMapState.gen.cs index 8dd7315d74..59f9f986c3 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/BufferMapState.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/BufferMapState.gen.cs @@ -13,11 +13,11 @@ namespace Silk.NET.WebGPU public enum BufferMapState : int { [NativeName("Name", "WGPUBufferMapState_Unmapped")] - Unmapped = 0x0, + Unmapped = 0x1, [NativeName("Name", "WGPUBufferMapState_Pending")] - Pending = 0x1, + Pending = 0x2, [NativeName("Name", "WGPUBufferMapState_Mapped")] - Mapped = 0x2, + Mapped = 0x3, [NativeName("Name", "WGPUBufferMapState_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/CallbackMode.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/CallbackMode.gen.cs similarity index 94% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/CallbackMode.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Enums/CallbackMode.gen.cs index 1b174323f9..e950eec976 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/CallbackMode.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/CallbackMode.gen.cs @@ -7,7 +7,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUCallbackMode")] public enum CallbackMode : int diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/CompareFunction.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/CompareFunction.gen.cs index 30b255aa75..a42f237d7e 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/CompareFunction.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/CompareFunction.gen.cs @@ -18,16 +18,16 @@ public enum CompareFunction : int Never = 0x1, [NativeName("Name", "WGPUCompareFunction_Less")] Less = 0x2, + [NativeName("Name", "WGPUCompareFunction_Equal")] + Equal = 0x3, [NativeName("Name", "WGPUCompareFunction_LessEqual")] - LessEqual = 0x3, + LessEqual = 0x4, [NativeName("Name", "WGPUCompareFunction_Greater")] - Greater = 0x4, - [NativeName("Name", "WGPUCompareFunction_GreaterEqual")] - GreaterEqual = 0x5, - [NativeName("Name", "WGPUCompareFunction_Equal")] - Equal = 0x6, + Greater = 0x5, [NativeName("Name", "WGPUCompareFunction_NotEqual")] - NotEqual = 0x7, + NotEqual = 0x6, + [NativeName("Name", "WGPUCompareFunction_GreaterEqual")] + GreaterEqual = 0x7, [NativeName("Name", "WGPUCompareFunction_Always")] Always = 0x8, [NativeName("Name", "WGPUCompareFunction_Force32")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/CompilationInfoRequestStatus.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/CompilationInfoRequestStatus.gen.cs index 949df6a87b..50846f33fe 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/CompilationInfoRequestStatus.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/CompilationInfoRequestStatus.gen.cs @@ -13,13 +13,9 @@ namespace Silk.NET.WebGPU public enum CompilationInfoRequestStatus : int { [NativeName("Name", "WGPUCompilationInfoRequestStatus_Success")] - Success = 0x0, - [NativeName("Name", "WGPUCompilationInfoRequestStatus_Error")] - Error = 0x1, - [NativeName("Name", "WGPUCompilationInfoRequestStatus_DeviceLost")] - DeviceLost = 0x2, - [NativeName("Name", "WGPUCompilationInfoRequestStatus_Unknown")] - Unknown = 0x3, + Success = 0x1, + [NativeName("Name", "WGPUCompilationInfoRequestStatus_CallbackCancelled")] + CallbackCancelled = 0x2, [NativeName("Name", "WGPUCompilationInfoRequestStatus_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/CompilationMessageType.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/CompilationMessageType.gen.cs index f0927839e6..8d133dc73e 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/CompilationMessageType.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/CompilationMessageType.gen.cs @@ -13,11 +13,11 @@ namespace Silk.NET.WebGPU public enum CompilationMessageType : int { [NativeName("Name", "WGPUCompilationMessageType_Error")] - Error = 0x0, + Error = 0x1, [NativeName("Name", "WGPUCompilationMessageType_Warning")] - Warning = 0x1, + Warning = 0x2, [NativeName("Name", "WGPUCompilationMessageType_Info")] - Info = 0x2, + Info = 0x3, [NativeName("Name", "WGPUCompilationMessageType_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/CreatePipelineAsyncStatus.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/CreatePipelineAsyncStatus.gen.cs index fef976c281..c2f040feb7 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/CreatePipelineAsyncStatus.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/CreatePipelineAsyncStatus.gen.cs @@ -13,17 +13,13 @@ namespace Silk.NET.WebGPU public enum CreatePipelineAsyncStatus : int { [NativeName("Name", "WGPUCreatePipelineAsyncStatus_Success")] - Success = 0x0, + Success = 0x1, + [NativeName("Name", "WGPUCreatePipelineAsyncStatus_CallbackCancelled")] + CallbackCancelled = 0x2, [NativeName("Name", "WGPUCreatePipelineAsyncStatus_ValidationError")] - ValidationError = 0x1, + ValidationError = 0x3, [NativeName("Name", "WGPUCreatePipelineAsyncStatus_InternalError")] - InternalError = 0x2, - [NativeName("Name", "WGPUCreatePipelineAsyncStatus_DeviceLost")] - DeviceLost = 0x3, - [NativeName("Name", "WGPUCreatePipelineAsyncStatus_DeviceDestroyed")] - DeviceDestroyed = 0x4, - [NativeName("Name", "WGPUCreatePipelineAsyncStatus_Unknown")] - Unknown = 0x5, + InternalError = 0x4, [NativeName("Name", "WGPUCreatePipelineAsyncStatus_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/CullMode.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/CullMode.gen.cs index ad5a1ffe57..da2a538ea0 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/CullMode.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/CullMode.gen.cs @@ -12,12 +12,14 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUCullMode")] public enum CullMode : int { + [NativeName("Name", "WGPUCullMode_Undefined")] + Undefined = 0x0, [NativeName("Name", "WGPUCullMode_None")] - None = 0x0, + None = 0x1, [NativeName("Name", "WGPUCullMode_Front")] - Front = 0x1, + Front = 0x2, [NativeName("Name", "WGPUCullMode_Back")] - Back = 0x2, + Back = 0x3, [NativeName("Name", "WGPUCullMode_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/DeviceLostReason.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/DeviceLostReason.gen.cs index 43853de5fd..a5f03f2bb6 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/DeviceLostReason.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/DeviceLostReason.gen.cs @@ -16,6 +16,10 @@ public enum DeviceLostReason : int Unknown = 0x1, [NativeName("Name", "WGPUDeviceLostReason_Destroyed")] Destroyed = 0x2, + [NativeName("Name", "WGPUDeviceLostReason_CallbackCancelled")] + CallbackCancelled = 0x3, + [NativeName("Name", "WGPUDeviceLostReason_FailedCreation")] + FailedCreation = 0x4, [NativeName("Name", "WGPUDeviceLostReason_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/ErrorFilter.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/ErrorFilter.gen.cs index d7ce6108d8..707218d2e8 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/ErrorFilter.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/ErrorFilter.gen.cs @@ -13,11 +13,11 @@ namespace Silk.NET.WebGPU public enum ErrorFilter : int { [NativeName("Name", "WGPUErrorFilter_Validation")] - Validation = 0x0, + Validation = 0x1, [NativeName("Name", "WGPUErrorFilter_OutOfMemory")] - OutOfMemory = 0x1, + OutOfMemory = 0x2, [NativeName("Name", "WGPUErrorFilter_Internal")] - Internal = 0x2, + Internal = 0x3, [NativeName("Name", "WGPUErrorFilter_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/ErrorType.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/ErrorType.gen.cs index c532d1998d..6135963800 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/ErrorType.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/ErrorType.gen.cs @@ -13,17 +13,15 @@ namespace Silk.NET.WebGPU public enum ErrorType : int { [NativeName("Name", "WGPUErrorType_NoError")] - NoError = 0x0, + NoError = 0x1, [NativeName("Name", "WGPUErrorType_Validation")] - Validation = 0x1, + Validation = 0x2, [NativeName("Name", "WGPUErrorType_OutOfMemory")] - OutOfMemory = 0x2, + OutOfMemory = 0x3, [NativeName("Name", "WGPUErrorType_Internal")] - Internal = 0x3, + Internal = 0x4, [NativeName("Name", "WGPUErrorType_Unknown")] - Unknown = 0x4, - [NativeName("Name", "WGPUErrorType_DeviceLost")] - DeviceLost = 0x5, + Unknown = 0x5, [NativeName("Name", "WGPUErrorType_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/FeatureLevel.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/FeatureLevel.gen.cs new file mode 100644 index 0000000000..4754594e10 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/FeatureLevel.gen.cs @@ -0,0 +1,24 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUFeatureLevel")] + public enum FeatureLevel : int + { + [NativeName("Name", "WGPUFeatureLevel_Undefined")] + Undefined = 0x0, + [NativeName("Name", "WGPUFeatureLevel_Compatibility")] + Compatibility = 0x1, + [NativeName("Name", "WGPUFeatureLevel_Core")] + Core = 0x2, + [NativeName("Name", "WGPUFeatureLevel_Force32")] + Force32 = 0x7FFFFFFF, + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/FeatureName.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/FeatureName.gen.cs index 679e430273..ae2296d8ce 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/FeatureName.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/FeatureName.gen.cs @@ -12,30 +12,52 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUFeatureName")] public enum FeatureName : int { - [NativeName("Name", "WGPUFeatureName_Undefined")] - Undefined = 0x0, + [NativeName("Name", "WGPUFeatureName_TextureCompressionBCSliced3D")] + TextureCompressionBCSliced3D = 0x5, + [NativeName("Name", "WGPUFeatureName_TextureCompressionASTCSliced3D")] + TextureCompressionAstcSliced3D = 0x8, + [NativeName("Name", "WGPUFeatureName_CoreFeaturesAndLimits")] + CoreFeaturesAndLimits = 0x1, [NativeName("Name", "WGPUFeatureName_DepthClipControl")] - DepthClipControl = 0x1, + DepthClipControl = 0x2, [NativeName("Name", "WGPUFeatureName_Depth32FloatStencil8")] - Depth32floatStencil8 = 0x2, - [NativeName("Name", "WGPUFeatureName_TimestampQuery")] - TimestampQuery = 0x3, + Depth32floatStencil8 = 0x3, [NativeName("Name", "WGPUFeatureName_TextureCompressionBC")] TextureCompressionBC = 0x4, + [Obsolete("Deprecated in favour of \"TextureCompressionBCSliced3D\"")] + [NativeName("Name", "WGPUFeatureName_TextureCompressionBCSliced3D")] + TextureCompressionBcsliced3D = 0x5, [NativeName("Name", "WGPUFeatureName_TextureCompressionETC2")] - TextureCompressionEtc2 = 0x5, + TextureCompressionEtc2 = 0x6, [NativeName("Name", "WGPUFeatureName_TextureCompressionASTC")] - TextureCompressionAstc = 0x6, + TextureCompressionAstc = 0x7, + [Obsolete("Deprecated in favour of \"TextureCompressionAstcSliced3D\"")] + [NativeName("Name", "WGPUFeatureName_TextureCompressionASTCSliced3D")] + TextureCompressionAstcsliced3D = 0x8, + [NativeName("Name", "WGPUFeatureName_TimestampQuery")] + TimestampQuery = 0x9, [NativeName("Name", "WGPUFeatureName_IndirectFirstInstance")] - IndirectFirstInstance = 0x7, + IndirectFirstInstance = 0xA, [NativeName("Name", "WGPUFeatureName_ShaderF16")] - ShaderF16 = 0x8, + ShaderF16 = 0xB, [NativeName("Name", "WGPUFeatureName_RG11B10UfloatRenderable")] - RG11B10UfloatRenderable = 0x9, + RG11B10UfloatRenderable = 0xC, [NativeName("Name", "WGPUFeatureName_BGRA8UnormStorage")] - Bgra8UnormStorage = 0xA, + Bgra8UnormStorage = 0xD, [NativeName("Name", "WGPUFeatureName_Float32Filterable")] - Float32filterable = 0xB, + Float32filterable = 0xE, + [NativeName("Name", "WGPUFeatureName_Float32Blendable")] + Float32Blendable = 0xF, + [NativeName("Name", "WGPUFeatureName_ClipDistances")] + ClipDistances = 0x10, + [NativeName("Name", "WGPUFeatureName_DualSourceBlending")] + DualSourceBlending = 0x11, + [NativeName("Name", "WGPUFeatureName_Subgroups")] + Subgroups = 0x12, + [NativeName("Name", "WGPUFeatureName_TextureFormatsTier1")] + TextureFormatsTier1 = 0x13, + [NativeName("Name", "WGPUFeatureName_TextureFormatsTier2")] + TextureFormatsTier2 = 0x14, [NativeName("Name", "WGPUFeatureName_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/FilterMode.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/FilterMode.gen.cs index 9756573284..b87f434e46 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/FilterMode.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/FilterMode.gen.cs @@ -12,10 +12,12 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUFilterMode")] public enum FilterMode : int { + [NativeName("Name", "WGPUFilterMode_Undefined")] + Undefined = 0x0, [NativeName("Name", "WGPUFilterMode_Nearest")] - Nearest = 0x0, + Nearest = 0x1, [NativeName("Name", "WGPUFilterMode_Linear")] - Linear = 0x1, + Linear = 0x2, [NativeName("Name", "WGPUFilterMode_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/FrontFace.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/FrontFace.gen.cs index eded973496..2777ebcf56 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/FrontFace.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/FrontFace.gen.cs @@ -12,10 +12,12 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUFrontFace")] public enum FrontFace : int { + [NativeName("Name", "WGPUFrontFace_Undefined")] + Undefined = 0x0, [NativeName("Name", "WGPUFrontFace_CCW")] - Ccw = 0x0, + Ccw = 0x1, [NativeName("Name", "WGPUFrontFace_CW")] - CW = 0x1, + CW = 0x2, [NativeName("Name", "WGPUFrontFace_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/InstanceFeatureName.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/InstanceFeatureName.gen.cs new file mode 100644 index 0000000000..cbe928f15f --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/InstanceFeatureName.gen.cs @@ -0,0 +1,24 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUInstanceFeatureName")] + public enum InstanceFeatureName : int + { + [NativeName("Name", "WGPUInstanceFeatureName_TimedWaitAny")] + TimedWaitAny = 0x1, + [NativeName("Name", "WGPUInstanceFeatureName_ShaderSourceSPIRV")] + ShaderSourceSpirv = 0x2, + [NativeName("Name", "WGPUInstanceFeatureName_MultipleDevicesPerAdapter")] + MultipleDevicesPerAdapter = 0x3, + [NativeName("Name", "WGPUInstanceFeatureName_Force32")] + Force32 = 0x7FFFFFFF, + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/LoadOp.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/LoadOp.gen.cs index af7967d2fe..f3a48a72ca 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/LoadOp.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/LoadOp.gen.cs @@ -14,10 +14,10 @@ public enum LoadOp : int { [NativeName("Name", "WGPULoadOp_Undefined")] Undefined = 0x0, - [NativeName("Name", "WGPULoadOp_Clear")] - Clear = 0x1, [NativeName("Name", "WGPULoadOp_Load")] - Load = 0x2, + Load = 0x1, + [NativeName("Name", "WGPULoadOp_Clear")] + Clear = 0x2, [NativeName("Name", "WGPULoadOp_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/MapAsyncStatus.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/MapAsyncStatus.gen.cs new file mode 100644 index 0000000000..c297950023 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/MapAsyncStatus.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUMapAsyncStatus")] + public enum MapAsyncStatus : int + { + [NativeName("Name", "WGPUMapAsyncStatus_Success")] + Success = 0x1, + [NativeName("Name", "WGPUMapAsyncStatus_CallbackCancelled")] + CallbackCancelled = 0x2, + [NativeName("Name", "WGPUMapAsyncStatus_Error")] + Error = 0x3, + [NativeName("Name", "WGPUMapAsyncStatus_Aborted")] + Aborted = 0x4, + [NativeName("Name", "WGPUMapAsyncStatus_Force32")] + Force32 = 0x7FFFFFFF, + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/MipmapFilterMode.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/MipmapFilterMode.gen.cs index 8357304b54..12129abd25 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/MipmapFilterMode.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/MipmapFilterMode.gen.cs @@ -12,10 +12,12 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUMipmapFilterMode")] public enum MipmapFilterMode : int { + [NativeName("Name", "WGPUMipmapFilterMode_Undefined")] + Undefined = 0x0, [NativeName("Name", "WGPUMipmapFilterMode_Nearest")] - Nearest = 0x0, + Nearest = 0x1, [NativeName("Name", "WGPUMipmapFilterMode_Linear")] - Linear = 0x1, + Linear = 0x2, [NativeName("Name", "WGPUMipmapFilterMode_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/OptionalBool.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/OptionalBool.gen.cs new file mode 100644 index 0000000000..fe01d05c2f --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/OptionalBool.gen.cs @@ -0,0 +1,24 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUOptionalBool")] + public enum OptionalBool : int + { + [NativeName("Name", "WGPUOptionalBool_False")] + False = 0x0, + [NativeName("Name", "WGPUOptionalBool_True")] + True = 0x1, + [NativeName("Name", "WGPUOptionalBool_Undefined")] + Undefined = 0x2, + [NativeName("Name", "WGPUOptionalBool_Force32")] + Force32 = 0x7FFFFFFF, + } +} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/PopErrorScopeStatus.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/PopErrorScopeStatus.gen.cs similarity index 66% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/PopErrorScopeStatus.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Enums/PopErrorScopeStatus.gen.cs index c2ac1afa26..44c0008d6f 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/PopErrorScopeStatus.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/PopErrorScopeStatus.gen.cs @@ -7,15 +7,17 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUPopErrorScopeStatus")] public enum PopErrorScopeStatus : int { [NativeName("Name", "WGPUPopErrorScopeStatus_Success")] - Success = 0x0, - [NativeName("Name", "WGPUPopErrorScopeStatus_InstanceDropped")] - InstanceDropped = 0x1, + Success = 0x1, + [NativeName("Name", "WGPUPopErrorScopeStatus_CallbackCancelled")] + CallbackCancelled = 0x2, + [NativeName("Name", "WGPUPopErrorScopeStatus_Error")] + Error = 0x3, [NativeName("Name", "WGPUPopErrorScopeStatus_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/PredefinedColorSpace.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/PredefinedColorSpace.gen.cs new file mode 100644 index 0000000000..d93cc3ece3 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/PredefinedColorSpace.gen.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUPredefinedColorSpace")] + public enum PredefinedColorSpace : int + { + [NativeName("Name", "WGPUPredefinedColorSpace_SRGB")] + Srgb = 0x1, + [NativeName("Name", "WGPUPredefinedColorSpace_DisplayP3")] + DisplayP3 = 0x2, + [NativeName("Name", "WGPUPredefinedColorSpace_Force32")] + Force32 = 0x7FFFFFFF, + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/PresentMode.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/PresentMode.gen.cs index 1f2d582248..8987991d19 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/PresentMode.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/PresentMode.gen.cs @@ -12,14 +12,16 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUPresentMode")] public enum PresentMode : int { + [NativeName("Name", "WGPUPresentMode_Undefined")] + Undefined = 0x0, [NativeName("Name", "WGPUPresentMode_Fifo")] - Fifo = 0x0, + Fifo = 0x1, [NativeName("Name", "WGPUPresentMode_FifoRelaxed")] - FifoRelaxed = 0x1, + FifoRelaxed = 0x2, [NativeName("Name", "WGPUPresentMode_Immediate")] - Immediate = 0x2, + Immediate = 0x3, [NativeName("Name", "WGPUPresentMode_Mailbox")] - Mailbox = 0x3, + Mailbox = 0x4, [NativeName("Name", "WGPUPresentMode_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/PrimitiveTopology.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/PrimitiveTopology.gen.cs index 2b16b7b99b..04f01bbbe1 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/PrimitiveTopology.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/PrimitiveTopology.gen.cs @@ -12,16 +12,18 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUPrimitiveTopology")] public enum PrimitiveTopology : int { + [NativeName("Name", "WGPUPrimitiveTopology_Undefined")] + Undefined = 0x0, [NativeName("Name", "WGPUPrimitiveTopology_PointList")] - PointList = 0x0, + PointList = 0x1, [NativeName("Name", "WGPUPrimitiveTopology_LineList")] - LineList = 0x1, + LineList = 0x2, [NativeName("Name", "WGPUPrimitiveTopology_LineStrip")] - LineStrip = 0x2, + LineStrip = 0x3, [NativeName("Name", "WGPUPrimitiveTopology_TriangleList")] - TriangleList = 0x3, + TriangleList = 0x4, [NativeName("Name", "WGPUPrimitiveTopology_TriangleStrip")] - TriangleStrip = 0x4, + TriangleStrip = 0x5, [NativeName("Name", "WGPUPrimitiveTopology_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/QueryType.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/QueryType.gen.cs index a2accaa58f..881b81e415 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/QueryType.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/QueryType.gen.cs @@ -13,9 +13,9 @@ namespace Silk.NET.WebGPU public enum QueryType : int { [NativeName("Name", "WGPUQueryType_Occlusion")] - Occlusion = 0x0, + Occlusion = 0x1, [NativeName("Name", "WGPUQueryType_Timestamp")] - Timestamp = 0x1, + Timestamp = 0x2, [NativeName("Name", "WGPUQueryType_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/QueueWorkDoneStatus.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/QueueWorkDoneStatus.gen.cs index 9cd643998b..6708a03e78 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/QueueWorkDoneStatus.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/QueueWorkDoneStatus.gen.cs @@ -13,13 +13,11 @@ namespace Silk.NET.WebGPU public enum QueueWorkDoneStatus : int { [NativeName("Name", "WGPUQueueWorkDoneStatus_Success")] - Success = 0x0, + Success = 0x1, + [NativeName("Name", "WGPUQueueWorkDoneStatus_CallbackCancelled")] + CallbackCancelled = 0x2, [NativeName("Name", "WGPUQueueWorkDoneStatus_Error")] - Error = 0x1, - [NativeName("Name", "WGPUQueueWorkDoneStatus_Unknown")] - Unknown = 0x2, - [NativeName("Name", "WGPUQueueWorkDoneStatus_DeviceLost")] - DeviceLost = 0x3, + Error = 0x3, [NativeName("Name", "WGPUQueueWorkDoneStatus_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/RequestAdapterStatus.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/RequestAdapterStatus.gen.cs index 62517b1ae3..466d5960a4 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/RequestAdapterStatus.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/RequestAdapterStatus.gen.cs @@ -13,13 +13,13 @@ namespace Silk.NET.WebGPU public enum RequestAdapterStatus : int { [NativeName("Name", "WGPURequestAdapterStatus_Success")] - Success = 0x0, + Success = 0x1, + [NativeName("Name", "WGPURequestAdapterStatus_CallbackCancelled")] + CallbackCancelled = 0x2, [NativeName("Name", "WGPURequestAdapterStatus_Unavailable")] - Unavailable = 0x1, + Unavailable = 0x3, [NativeName("Name", "WGPURequestAdapterStatus_Error")] - Error = 0x2, - [NativeName("Name", "WGPURequestAdapterStatus_Unknown")] - Unknown = 0x3, + Error = 0x4, [NativeName("Name", "WGPURequestAdapterStatus_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/RequestDeviceStatus.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/RequestDeviceStatus.gen.cs index b6bd4ca9ad..e1469c229a 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/RequestDeviceStatus.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/RequestDeviceStatus.gen.cs @@ -13,11 +13,11 @@ namespace Silk.NET.WebGPU public enum RequestDeviceStatus : int { [NativeName("Name", "WGPURequestDeviceStatus_Success")] - Success = 0x0, + Success = 0x1, + [NativeName("Name", "WGPURequestDeviceStatus_CallbackCancelled")] + CallbackCancelled = 0x2, [NativeName("Name", "WGPURequestDeviceStatus_Error")] - Error = 0x1, - [NativeName("Name", "WGPURequestDeviceStatus_Unknown")] - Unknown = 0x2, + Error = 0x3, [NativeName("Name", "WGPURequestDeviceStatus_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/SType.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/SType.gen.cs index f294faf663..030fef7dc3 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/SType.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/SType.gen.cs @@ -12,39 +12,34 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUSType")] public enum SType : int { - [NativeName("Name", "WGPUSType_SurfaceDescriptorFromCanvasHTMLSelector")] - SurfaceDescriptorFromCanvasHtmlSelector = 0x4, - [NativeName("Name", "WGPUSType_ShaderModuleSPIRVDescriptor")] - ShaderModuleSpirvDescriptor = 0x5, - [NativeName("Name", "WGPUSType_ShaderModuleWGSLDescriptor")] - ShaderModuleWgslDescriptor = 0x6, - [NativeName("Name", "WGPUSType_Invalid")] - Invalid = 0x0, - [NativeName("Name", "WGPUSType_SurfaceDescriptorFromMetalLayer")] - SurfaceDescriptorFromMetalLayer = 0x1, - [NativeName("Name", "WGPUSType_SurfaceDescriptorFromWindowsHWND")] - SurfaceDescriptorFromWindowsHwnd = 0x2, - [NativeName("Name", "WGPUSType_SurfaceDescriptorFromXlibWindow")] - SurfaceDescriptorFromXlibWindow = 0x3, - [Obsolete("Deprecated in favour of \"SurfaceDescriptorFromCanvasHtmlSelector\"")] - [NativeName("Name", "WGPUSType_SurfaceDescriptorFromCanvasHTMLSelector")] - SurfaceDescriptorFromCanvasHtmlselector = 0x4, - [Obsolete("Deprecated in favour of \"ShaderModuleSpirvDescriptor\"")] - [NativeName("Name", "WGPUSType_ShaderModuleSPIRVDescriptor")] - ShaderModuleSpirvdescriptor = 0x5, - [Obsolete("Deprecated in favour of \"ShaderModuleWgslDescriptor\"")] - [NativeName("Name", "WGPUSType_ShaderModuleWGSLDescriptor")] - ShaderModuleWgsldescriptor = 0x6, - [NativeName("Name", "WGPUSType_PrimitiveDepthClipControl")] - PrimitiveDepthClipControl = 0x7, - [NativeName("Name", "WGPUSType_SurfaceDescriptorFromWaylandSurface")] - SurfaceDescriptorFromWaylandSurface = 0x8, - [NativeName("Name", "WGPUSType_SurfaceDescriptorFromAndroidNativeWindow")] - SurfaceDescriptorFromAndroidNativeWindow = 0x9, - [NativeName("Name", "WGPUSType_SurfaceDescriptorFromXcbWindow")] - SurfaceDescriptorFromXcbWindow = 0xA, - [NativeName("Name", "WGPUSType_RenderPassDescriptorMaxDrawCount")] - RenderPassDescriptorMaxDrawCount = 0xF, + [NativeName("Name", "WGPUSType_SurfaceSourceXCBWindow")] + SurfaceSourceXcbWindow = 0x9, + [NativeName("Name", "WGPUSType_RequestAdapterWebXROptions")] + RequestAdapterWebXROptions = 0xB, + [NativeName("Name", "WGPUSType_ShaderSourceSPIRV")] + ShaderSourceSpirv = 0x1, + [NativeName("Name", "WGPUSType_ShaderSourceWGSL")] + ShaderSourceWgsl = 0x2, + [NativeName("Name", "WGPUSType_RenderPassMaxDrawCount")] + RenderPassMaxDrawCount = 0x3, + [NativeName("Name", "WGPUSType_SurfaceSourceMetalLayer")] + SurfaceSourceMetalLayer = 0x4, + [NativeName("Name", "WGPUSType_SurfaceSourceWindowsHWND")] + SurfaceSourceWindowsHwnd = 0x5, + [NativeName("Name", "WGPUSType_SurfaceSourceXlibWindow")] + SurfaceSourceXlibWindow = 0x6, + [NativeName("Name", "WGPUSType_SurfaceSourceWaylandSurface")] + SurfaceSourceWaylandSurface = 0x7, + [NativeName("Name", "WGPUSType_SurfaceSourceAndroidNativeWindow")] + SurfaceSourceAndroidNativeWindow = 0x8, + [Obsolete("Deprecated in favour of \"SurfaceSourceXcbWindow\"")] + [NativeName("Name", "WGPUSType_SurfaceSourceXCBWindow")] + SurfaceSourceXcbwindow = 0x9, + [NativeName("Name", "WGPUSType_SurfaceColorManagement")] + SurfaceColorManagement = 0xA, + [Obsolete("Deprecated in favour of \"RequestAdapterWebXROptions\"")] + [NativeName("Name", "WGPUSType_RequestAdapterWebXROptions")] + RequestAdapterWebXroptions = 0xB, [NativeName("Name", "WGPUSType_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/SamplerBindingType.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/SamplerBindingType.gen.cs index 538dcd6615..81c62ed71c 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/SamplerBindingType.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/SamplerBindingType.gen.cs @@ -12,14 +12,16 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUSamplerBindingType")] public enum SamplerBindingType : int { + [NativeName("Name", "WGPUSamplerBindingType_BindingNotUsed")] + BindingNotUsed = 0x0, [NativeName("Name", "WGPUSamplerBindingType_Undefined")] - Undefined = 0x0, + Undefined = 0x1, [NativeName("Name", "WGPUSamplerBindingType_Filtering")] - Filtering = 0x1, + Filtering = 0x2, [NativeName("Name", "WGPUSamplerBindingType_NonFiltering")] - NonFiltering = 0x2, + NonFiltering = 0x3, [NativeName("Name", "WGPUSamplerBindingType_Comparison")] - Comparison = 0x3, + Comparison = 0x4, [NativeName("Name", "WGPUSamplerBindingType_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/Status.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/Status.gen.cs similarity index 84% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/Status.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Enums/Status.gen.cs index 2b9ff5f919..c0bcf75146 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/Status.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/Status.gen.cs @@ -7,15 +7,15 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUStatus")] public enum Status : int { [NativeName("Name", "WGPUStatus_Success")] - Success = 0x0, + Success = 0x1, [NativeName("Name", "WGPUStatus_Error")] - Error = 0x1, + Error = 0x2, [NativeName("Name", "WGPUStatus_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/StencilOperation.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/StencilOperation.gen.cs index 49684e0ec5..0f3bdec197 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/StencilOperation.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/StencilOperation.gen.cs @@ -12,22 +12,24 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUStencilOperation")] public enum StencilOperation : int { + [NativeName("Name", "WGPUStencilOperation_Undefined")] + Undefined = 0x0, [NativeName("Name", "WGPUStencilOperation_Keep")] - Keep = 0x0, + Keep = 0x1, [NativeName("Name", "WGPUStencilOperation_Zero")] - Zero = 0x1, + Zero = 0x2, [NativeName("Name", "WGPUStencilOperation_Replace")] - Replace = 0x2, + Replace = 0x3, [NativeName("Name", "WGPUStencilOperation_Invert")] - Invert = 0x3, + Invert = 0x4, [NativeName("Name", "WGPUStencilOperation_IncrementClamp")] - IncrementClamp = 0x4, + IncrementClamp = 0x5, [NativeName("Name", "WGPUStencilOperation_DecrementClamp")] - DecrementClamp = 0x5, + DecrementClamp = 0x6, [NativeName("Name", "WGPUStencilOperation_IncrementWrap")] - IncrementWrap = 0x6, + IncrementWrap = 0x7, [NativeName("Name", "WGPUStencilOperation_DecrementWrap")] - DecrementWrap = 0x7, + DecrementWrap = 0x8, [NativeName("Name", "WGPUStencilOperation_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/StorageTextureAccess.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/StorageTextureAccess.gen.cs index 7ce6981da5..b9a94b6bcd 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/StorageTextureAccess.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/StorageTextureAccess.gen.cs @@ -12,14 +12,16 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUStorageTextureAccess")] public enum StorageTextureAccess : int { + [NativeName("Name", "WGPUStorageTextureAccess_BindingNotUsed")] + BindingNotUsed = 0x0, [NativeName("Name", "WGPUStorageTextureAccess_Undefined")] - Undefined = 0x0, + Undefined = 0x1, [NativeName("Name", "WGPUStorageTextureAccess_WriteOnly")] - WriteOnly = 0x1, + WriteOnly = 0x2, [NativeName("Name", "WGPUStorageTextureAccess_ReadOnly")] - ReadOnly = 0x2, + ReadOnly = 0x3, [NativeName("Name", "WGPUStorageTextureAccess_ReadWrite")] - ReadWrite = 0x3, + ReadWrite = 0x4, [NativeName("Name", "WGPUStorageTextureAccess_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/SurfaceGetCurrentTextureStatus.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/SurfaceGetCurrentTextureStatus.gen.cs index eab5d725ab..c895b682b6 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/SurfaceGetCurrentTextureStatus.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/SurfaceGetCurrentTextureStatus.gen.cs @@ -12,18 +12,18 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUSurfaceGetCurrentTextureStatus")] public enum SurfaceGetCurrentTextureStatus : int { - [NativeName("Name", "WGPUSurfaceGetCurrentTextureStatus_Success")] - Success = 0x0, + [NativeName("Name", "WGPUSurfaceGetCurrentTextureStatus_SuccessOptimal")] + SuccessOptimal = 0x1, + [NativeName("Name", "WGPUSurfaceGetCurrentTextureStatus_SuccessSuboptimal")] + SuccessSuboptimal = 0x2, [NativeName("Name", "WGPUSurfaceGetCurrentTextureStatus_Timeout")] - Timeout = 0x1, + Timeout = 0x3, [NativeName("Name", "WGPUSurfaceGetCurrentTextureStatus_Outdated")] - Outdated = 0x2, + Outdated = 0x4, [NativeName("Name", "WGPUSurfaceGetCurrentTextureStatus_Lost")] - Lost = 0x3, - [NativeName("Name", "WGPUSurfaceGetCurrentTextureStatus_OutOfMemory")] - OutOfMemory = 0x4, - [NativeName("Name", "WGPUSurfaceGetCurrentTextureStatus_DeviceLost")] - DeviceLost = 0x5, + Lost = 0x5, + [NativeName("Name", "WGPUSurfaceGetCurrentTextureStatus_Error")] + Error = 0x6, [NativeName("Name", "WGPUSurfaceGetCurrentTextureStatus_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/TextureAspect.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/TextureAspect.gen.cs index d7eccf7427..4c98713725 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/TextureAspect.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/TextureAspect.gen.cs @@ -12,12 +12,14 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUTextureAspect")] public enum TextureAspect : int { + [NativeName("Name", "WGPUTextureAspect_Undefined")] + Undefined = 0x0, [NativeName("Name", "WGPUTextureAspect_All")] - All = 0x0, + All = 0x1, [NativeName("Name", "WGPUTextureAspect_StencilOnly")] - StencilOnly = 0x1, + StencilOnly = 0x2, [NativeName("Name", "WGPUTextureAspect_DepthOnly")] - DepthOnly = 0x2, + DepthOnly = 0x3, [NativeName("Name", "WGPUTextureAspect_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/TextureDimension.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/TextureDimension.gen.cs index 71feb20463..05c19fcb13 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/TextureDimension.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/TextureDimension.gen.cs @@ -12,24 +12,29 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUTextureDimension")] public enum TextureDimension : int { + [Obsolete("Deprecated in favour of \"DimensionUndefined\"")] + [NativeName("Name", "WGPUTextureDimension_Undefined")] + TextureDimensionUndefined = 0x0, [Obsolete("Deprecated in favour of \"Dimension1D\"")] [NativeName("Name", "WGPUTextureDimension_1D")] - TextureDimension1D = 0x0, + TextureDimension1D = 0x1, [Obsolete("Deprecated in favour of \"Dimension2D\"")] [NativeName("Name", "WGPUTextureDimension_2D")] - TextureDimension2D = 0x1, + TextureDimension2D = 0x2, [Obsolete("Deprecated in favour of \"Dimension3D\"")] [NativeName("Name", "WGPUTextureDimension_3D")] - TextureDimension3D = 0x2, + TextureDimension3D = 0x3, [Obsolete("Deprecated in favour of \"DimensionForce32\"")] [NativeName("Name", "WGPUTextureDimension_Force32")] TextureDimensionForce32 = 0x7FFFFFFF, + [NativeName("Name", "WGPUTextureDimension_Undefined")] + DimensionUndefined = 0x0, [NativeName("Name", "WGPUTextureDimension_1D")] - Dimension1D = 0x0, + Dimension1D = 0x1, [NativeName("Name", "WGPUTextureDimension_2D")] - Dimension2D = 0x1, + Dimension2D = 0x2, [NativeName("Name", "WGPUTextureDimension_3D")] - Dimension3D = 0x2, + Dimension3D = 0x3, [NativeName("Name", "WGPUTextureDimension_Force32")] DimensionForce32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/TextureFormat.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/TextureFormat.gen.cs index 483a0741e7..f80e039536 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/TextureFormat.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/TextureFormat.gen.cs @@ -13,29 +13,29 @@ namespace Silk.NET.WebGPU public enum TextureFormat : int { [NativeName("Name", "WGPUTextureFormat_BC1RGBAUnorm")] - BC1RgbaUnorm = 0x2C, + BC1RgbaUnorm = 0x32, [NativeName("Name", "WGPUTextureFormat_BC1RGBAUnormSrgb")] - BC1RgbaUnormSrgb = 0x2D, + BC1RgbaUnormSrgb = 0x33, [NativeName("Name", "WGPUTextureFormat_BC2RGBAUnorm")] - BC2RgbaUnorm = 0x2E, + BC2RgbaUnorm = 0x34, [NativeName("Name", "WGPUTextureFormat_BC2RGBAUnormSrgb")] - BC2RgbaUnormSrgb = 0x2F, + BC2RgbaUnormSrgb = 0x35, [NativeName("Name", "WGPUTextureFormat_BC3RGBAUnorm")] - BC3RgbaUnorm = 0x30, + BC3RgbaUnorm = 0x36, [NativeName("Name", "WGPUTextureFormat_BC3RGBAUnormSrgb")] - BC3RgbaUnormSrgb = 0x31, + BC3RgbaUnormSrgb = 0x37, [NativeName("Name", "WGPUTextureFormat_BC5RGUnorm")] - BC5RGUnorm = 0x34, + BC5RGUnorm = 0x3A, [NativeName("Name", "WGPUTextureFormat_BC5RGSnorm")] - BC5RGSnorm = 0x35, + BC5RGSnorm = 0x3B, [NativeName("Name", "WGPUTextureFormat_BC6HRGBUfloat")] - BC6HrgbUfloat = 0x36, + BC6HrgbUfloat = 0x3C, [NativeName("Name", "WGPUTextureFormat_BC6HRGBFloat")] - BC6HrgbFloat = 0x37, + BC6HrgbFloat = 0x3D, [NativeName("Name", "WGPUTextureFormat_BC7RGBAUnorm")] - BC7RgbaUnorm = 0x38, + BC7RgbaUnorm = 0x3E, [NativeName("Name", "WGPUTextureFormat_BC7RGBAUnormSrgb")] - BC7RgbaUnormSrgb = 0x39, + BC7RgbaUnormSrgb = 0x3F, [NativeName("Name", "WGPUTextureFormat_Undefined")] Undefined = 0x0, [NativeName("Name", "WGPUTextureFormat_R8Unorm")] @@ -46,200 +46,212 @@ public enum TextureFormat : int R8Uint = 0x3, [NativeName("Name", "WGPUTextureFormat_R8Sint")] R8Sint = 0x4, + [NativeName("Name", "WGPUTextureFormat_R16Unorm")] + R16Unorm = 0x5, + [NativeName("Name", "WGPUTextureFormat_R16Snorm")] + R16Snorm = 0x6, [NativeName("Name", "WGPUTextureFormat_R16Uint")] - R16Uint = 0x5, + R16Uint = 0x7, [NativeName("Name", "WGPUTextureFormat_R16Sint")] - R16Sint = 0x6, + R16Sint = 0x8, [NativeName("Name", "WGPUTextureFormat_R16Float")] - R16float = 0x7, + R16float = 0x9, [NativeName("Name", "WGPUTextureFormat_RG8Unorm")] - RG8Unorm = 0x8, + RG8Unorm = 0xA, [NativeName("Name", "WGPUTextureFormat_RG8Snorm")] - RG8Snorm = 0x9, + RG8Snorm = 0xB, [NativeName("Name", "WGPUTextureFormat_RG8Uint")] - RG8Uint = 0xA, + RG8Uint = 0xC, [NativeName("Name", "WGPUTextureFormat_RG8Sint")] - RG8Sint = 0xB, + RG8Sint = 0xD, [NativeName("Name", "WGPUTextureFormat_R32Float")] - R32float = 0xC, + R32float = 0xE, [NativeName("Name", "WGPUTextureFormat_R32Uint")] - R32Uint = 0xD, + R32Uint = 0xF, [NativeName("Name", "WGPUTextureFormat_R32Sint")] - R32Sint = 0xE, + R32Sint = 0x10, + [NativeName("Name", "WGPUTextureFormat_RG16Unorm")] + RG16Unorm = 0x11, + [NativeName("Name", "WGPUTextureFormat_RG16Snorm")] + RG16Snorm = 0x12, [NativeName("Name", "WGPUTextureFormat_RG16Uint")] - RG16Uint = 0xF, + RG16Uint = 0x13, [NativeName("Name", "WGPUTextureFormat_RG16Sint")] - RG16Sint = 0x10, + RG16Sint = 0x14, [NativeName("Name", "WGPUTextureFormat_RG16Float")] - RG16float = 0x11, + RG16float = 0x15, [NativeName("Name", "WGPUTextureFormat_RGBA8Unorm")] - Rgba8Unorm = 0x12, + Rgba8Unorm = 0x16, [NativeName("Name", "WGPUTextureFormat_RGBA8UnormSrgb")] - Rgba8UnormSrgb = 0x13, + Rgba8UnormSrgb = 0x17, [NativeName("Name", "WGPUTextureFormat_RGBA8Snorm")] - Rgba8Snorm = 0x14, + Rgba8Snorm = 0x18, [NativeName("Name", "WGPUTextureFormat_RGBA8Uint")] - Rgba8Uint = 0x15, + Rgba8Uint = 0x19, [NativeName("Name", "WGPUTextureFormat_RGBA8Sint")] - Rgba8Sint = 0x16, + Rgba8Sint = 0x1A, [NativeName("Name", "WGPUTextureFormat_BGRA8Unorm")] - Bgra8Unorm = 0x17, + Bgra8Unorm = 0x1B, [NativeName("Name", "WGPUTextureFormat_BGRA8UnormSrgb")] - Bgra8UnormSrgb = 0x18, + Bgra8UnormSrgb = 0x1C, [NativeName("Name", "WGPUTextureFormat_RGB10A2Uint")] - Rgb10A2Uint = 0x19, + Rgb10A2Uint = 0x1D, [NativeName("Name", "WGPUTextureFormat_RGB10A2Unorm")] - Rgb10A2Unorm = 0x1A, + Rgb10A2Unorm = 0x1E, [NativeName("Name", "WGPUTextureFormat_RG11B10Ufloat")] - RG11B10Ufloat = 0x1B, + RG11B10Ufloat = 0x1F, [NativeName("Name", "WGPUTextureFormat_RGB9E5Ufloat")] - Rgb9E5Ufloat = 0x1C, + Rgb9E5Ufloat = 0x20, [NativeName("Name", "WGPUTextureFormat_RG32Float")] - RG32float = 0x1D, + RG32float = 0x21, [NativeName("Name", "WGPUTextureFormat_RG32Uint")] - RG32Uint = 0x1E, + RG32Uint = 0x22, [NativeName("Name", "WGPUTextureFormat_RG32Sint")] - RG32Sint = 0x1F, + RG32Sint = 0x23, + [NativeName("Name", "WGPUTextureFormat_RGBA16Unorm")] + Rgba16Unorm = 0x24, + [NativeName("Name", "WGPUTextureFormat_RGBA16Snorm")] + Rgba16Snorm = 0x25, [NativeName("Name", "WGPUTextureFormat_RGBA16Uint")] - Rgba16Uint = 0x20, + Rgba16Uint = 0x26, [NativeName("Name", "WGPUTextureFormat_RGBA16Sint")] - Rgba16Sint = 0x21, + Rgba16Sint = 0x27, [NativeName("Name", "WGPUTextureFormat_RGBA16Float")] - Rgba16float = 0x22, + Rgba16float = 0x28, [NativeName("Name", "WGPUTextureFormat_RGBA32Float")] - Rgba32float = 0x23, + Rgba32float = 0x29, [NativeName("Name", "WGPUTextureFormat_RGBA32Uint")] - Rgba32Uint = 0x24, + Rgba32Uint = 0x2A, [NativeName("Name", "WGPUTextureFormat_RGBA32Sint")] - Rgba32Sint = 0x25, + Rgba32Sint = 0x2B, [NativeName("Name", "WGPUTextureFormat_Stencil8")] - Stencil8 = 0x26, + Stencil8 = 0x2C, [NativeName("Name", "WGPUTextureFormat_Depth16Unorm")] - Depth16Unorm = 0x27, + Depth16Unorm = 0x2D, [NativeName("Name", "WGPUTextureFormat_Depth24Plus")] - Depth24Plus = 0x28, + Depth24Plus = 0x2E, [NativeName("Name", "WGPUTextureFormat_Depth24PlusStencil8")] - Depth24PlusStencil8 = 0x29, + Depth24PlusStencil8 = 0x2F, [NativeName("Name", "WGPUTextureFormat_Depth32Float")] - Depth32float = 0x2A, + Depth32float = 0x30, [NativeName("Name", "WGPUTextureFormat_Depth32FloatStencil8")] - Depth32floatStencil8 = 0x2B, + Depth32floatStencil8 = 0x31, [Obsolete("Deprecated in favour of \"BC1RgbaUnorm\"")] [NativeName("Name", "WGPUTextureFormat_BC1RGBAUnorm")] - BC1Rgbaunorm = 0x2C, + BC1Rgbaunorm = 0x32, [Obsolete("Deprecated in favour of \"BC1RgbaUnormSrgb\"")] [NativeName("Name", "WGPUTextureFormat_BC1RGBAUnormSrgb")] - BC1RgbaunormSrgb = 0x2D, + BC1RgbaunormSrgb = 0x33, [Obsolete("Deprecated in favour of \"BC2RgbaUnorm\"")] [NativeName("Name", "WGPUTextureFormat_BC2RGBAUnorm")] - BC2Rgbaunorm = 0x2E, + BC2Rgbaunorm = 0x34, [Obsolete("Deprecated in favour of \"BC2RgbaUnormSrgb\"")] [NativeName("Name", "WGPUTextureFormat_BC2RGBAUnormSrgb")] - BC2RgbaunormSrgb = 0x2F, + BC2RgbaunormSrgb = 0x35, [Obsolete("Deprecated in favour of \"BC3RgbaUnorm\"")] [NativeName("Name", "WGPUTextureFormat_BC3RGBAUnorm")] - BC3Rgbaunorm = 0x30, + BC3Rgbaunorm = 0x36, [Obsolete("Deprecated in favour of \"BC3RgbaUnormSrgb\"")] [NativeName("Name", "WGPUTextureFormat_BC3RGBAUnormSrgb")] - BC3RgbaunormSrgb = 0x31, + BC3RgbaunormSrgb = 0x37, [NativeName("Name", "WGPUTextureFormat_BC4RUnorm")] - BC4RUnorm = 0x32, + BC4RUnorm = 0x38, [NativeName("Name", "WGPUTextureFormat_BC4RSnorm")] - BC4RSnorm = 0x33, + BC4RSnorm = 0x39, [Obsolete("Deprecated in favour of \"BC5RGUnorm\"")] [NativeName("Name", "WGPUTextureFormat_BC5RGUnorm")] - BC5Rgunorm = 0x34, + BC5Rgunorm = 0x3A, [Obsolete("Deprecated in favour of \"BC5RGSnorm\"")] [NativeName("Name", "WGPUTextureFormat_BC5RGSnorm")] - BC5Rgsnorm = 0x35, + BC5Rgsnorm = 0x3B, [Obsolete("Deprecated in favour of \"BC6HrgbUfloat\"")] [NativeName("Name", "WGPUTextureFormat_BC6HRGBUfloat")] - BC6Hrgbufloat = 0x36, + BC6Hrgbufloat = 0x3C, [Obsolete("Deprecated in favour of \"BC6HrgbFloat\"")] [NativeName("Name", "WGPUTextureFormat_BC6HRGBFloat")] - BC6Hrgbfloat = 0x37, + BC6Hrgbfloat = 0x3D, [Obsolete("Deprecated in favour of \"BC7RgbaUnorm\"")] [NativeName("Name", "WGPUTextureFormat_BC7RGBAUnorm")] - BC7Rgbaunorm = 0x38, + BC7Rgbaunorm = 0x3E, [Obsolete("Deprecated in favour of \"BC7RgbaUnormSrgb\"")] [NativeName("Name", "WGPUTextureFormat_BC7RGBAUnormSrgb")] - BC7RgbaunormSrgb = 0x39, + BC7RgbaunormSrgb = 0x3F, [NativeName("Name", "WGPUTextureFormat_ETC2RGB8Unorm")] - Etc2Rgb8Unorm = 0x3A, + Etc2Rgb8Unorm = 0x40, [NativeName("Name", "WGPUTextureFormat_ETC2RGB8UnormSrgb")] - Etc2Rgb8UnormSrgb = 0x3B, + Etc2Rgb8UnormSrgb = 0x41, [NativeName("Name", "WGPUTextureFormat_ETC2RGB8A1Unorm")] - Etc2Rgb8A1Unorm = 0x3C, + Etc2Rgb8A1Unorm = 0x42, [NativeName("Name", "WGPUTextureFormat_ETC2RGB8A1UnormSrgb")] - Etc2Rgb8A1UnormSrgb = 0x3D, + Etc2Rgb8A1UnormSrgb = 0x43, [NativeName("Name", "WGPUTextureFormat_ETC2RGBA8Unorm")] - Etc2Rgba8Unorm = 0x3E, + Etc2Rgba8Unorm = 0x44, [NativeName("Name", "WGPUTextureFormat_ETC2RGBA8UnormSrgb")] - Etc2Rgba8UnormSrgb = 0x3F, + Etc2Rgba8UnormSrgb = 0x45, [NativeName("Name", "WGPUTextureFormat_EACR11Unorm")] - Eacr11Unorm = 0x40, + Eacr11Unorm = 0x46, [NativeName("Name", "WGPUTextureFormat_EACR11Snorm")] - Eacr11Snorm = 0x41, + Eacr11Snorm = 0x47, [NativeName("Name", "WGPUTextureFormat_EACRG11Unorm")] - Eacrg11Unorm = 0x42, + Eacrg11Unorm = 0x48, [NativeName("Name", "WGPUTextureFormat_EACRG11Snorm")] - Eacrg11Snorm = 0x43, + Eacrg11Snorm = 0x49, [NativeName("Name", "WGPUTextureFormat_ASTC4x4Unorm")] - Astc4x4Unorm = 0x44, + Astc4x4Unorm = 0x4A, [NativeName("Name", "WGPUTextureFormat_ASTC4x4UnormSrgb")] - Astc4x4UnormSrgb = 0x45, + Astc4x4UnormSrgb = 0x4B, [NativeName("Name", "WGPUTextureFormat_ASTC5x4Unorm")] - Astc5x4Unorm = 0x46, + Astc5x4Unorm = 0x4C, [NativeName("Name", "WGPUTextureFormat_ASTC5x4UnormSrgb")] - Astc5x4UnormSrgb = 0x47, + Astc5x4UnormSrgb = 0x4D, [NativeName("Name", "WGPUTextureFormat_ASTC5x5Unorm")] - Astc5x5Unorm = 0x48, + Astc5x5Unorm = 0x4E, [NativeName("Name", "WGPUTextureFormat_ASTC5x5UnormSrgb")] - Astc5x5UnormSrgb = 0x49, + Astc5x5UnormSrgb = 0x4F, [NativeName("Name", "WGPUTextureFormat_ASTC6x5Unorm")] - Astc6x5Unorm = 0x4A, + Astc6x5Unorm = 0x50, [NativeName("Name", "WGPUTextureFormat_ASTC6x5UnormSrgb")] - Astc6x5UnormSrgb = 0x4B, + Astc6x5UnormSrgb = 0x51, [NativeName("Name", "WGPUTextureFormat_ASTC6x6Unorm")] - Astc6x6Unorm = 0x4C, + Astc6x6Unorm = 0x52, [NativeName("Name", "WGPUTextureFormat_ASTC6x6UnormSrgb")] - Astc6x6UnormSrgb = 0x4D, + Astc6x6UnormSrgb = 0x53, [NativeName("Name", "WGPUTextureFormat_ASTC8x5Unorm")] - Astc8x5Unorm = 0x4E, + Astc8x5Unorm = 0x54, [NativeName("Name", "WGPUTextureFormat_ASTC8x5UnormSrgb")] - Astc8x5UnormSrgb = 0x4F, + Astc8x5UnormSrgb = 0x55, [NativeName("Name", "WGPUTextureFormat_ASTC8x6Unorm")] - Astc8x6Unorm = 0x50, + Astc8x6Unorm = 0x56, [NativeName("Name", "WGPUTextureFormat_ASTC8x6UnormSrgb")] - Astc8x6UnormSrgb = 0x51, + Astc8x6UnormSrgb = 0x57, [NativeName("Name", "WGPUTextureFormat_ASTC8x8Unorm")] - Astc8x8Unorm = 0x52, + Astc8x8Unorm = 0x58, [NativeName("Name", "WGPUTextureFormat_ASTC8x8UnormSrgb")] - Astc8x8UnormSrgb = 0x53, + Astc8x8UnormSrgb = 0x59, [NativeName("Name", "WGPUTextureFormat_ASTC10x5Unorm")] - Astc10x5Unorm = 0x54, + Astc10x5Unorm = 0x5A, [NativeName("Name", "WGPUTextureFormat_ASTC10x5UnormSrgb")] - Astc10x5UnormSrgb = 0x55, + Astc10x5UnormSrgb = 0x5B, [NativeName("Name", "WGPUTextureFormat_ASTC10x6Unorm")] - Astc10x6Unorm = 0x56, + Astc10x6Unorm = 0x5C, [NativeName("Name", "WGPUTextureFormat_ASTC10x6UnormSrgb")] - Astc10x6UnormSrgb = 0x57, + Astc10x6UnormSrgb = 0x5D, [NativeName("Name", "WGPUTextureFormat_ASTC10x8Unorm")] - Astc10x8Unorm = 0x58, + Astc10x8Unorm = 0x5E, [NativeName("Name", "WGPUTextureFormat_ASTC10x8UnormSrgb")] - Astc10x8UnormSrgb = 0x59, + Astc10x8UnormSrgb = 0x5F, [NativeName("Name", "WGPUTextureFormat_ASTC10x10Unorm")] - Astc10x10Unorm = 0x5A, + Astc10x10Unorm = 0x60, [NativeName("Name", "WGPUTextureFormat_ASTC10x10UnormSrgb")] - Astc10x10UnormSrgb = 0x5B, + Astc10x10UnormSrgb = 0x61, [NativeName("Name", "WGPUTextureFormat_ASTC12x10Unorm")] - Astc12x10Unorm = 0x5C, + Astc12x10Unorm = 0x62, [NativeName("Name", "WGPUTextureFormat_ASTC12x10UnormSrgb")] - Astc12x10UnormSrgb = 0x5D, + Astc12x10UnormSrgb = 0x63, [NativeName("Name", "WGPUTextureFormat_ASTC12x12Unorm")] - Astc12x12Unorm = 0x5E, + Astc12x12Unorm = 0x64, [NativeName("Name", "WGPUTextureFormat_ASTC12x12UnormSrgb")] - Astc12x12UnormSrgb = 0x5F, + Astc12x12UnormSrgb = 0x65, [NativeName("Name", "WGPUTextureFormat_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/TextureSampleType.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/TextureSampleType.gen.cs index bf8ffa9976..64fa7a5095 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/TextureSampleType.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/TextureSampleType.gen.cs @@ -12,18 +12,20 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUTextureSampleType")] public enum TextureSampleType : int { + [NativeName("Name", "WGPUTextureSampleType_BindingNotUsed")] + BindingNotUsed = 0x0, [NativeName("Name", "WGPUTextureSampleType_Undefined")] - Undefined = 0x0, + Undefined = 0x1, [NativeName("Name", "WGPUTextureSampleType_Float")] - Float = 0x1, + Float = 0x2, [NativeName("Name", "WGPUTextureSampleType_UnfilterableFloat")] - UnfilterableFloat = 0x2, + UnfilterableFloat = 0x3, [NativeName("Name", "WGPUTextureSampleType_Depth")] - Depth = 0x3, + Depth = 0x4, [NativeName("Name", "WGPUTextureSampleType_Sint")] - Sint = 0x4, + Sint = 0x5, [NativeName("Name", "WGPUTextureSampleType_Uint")] - Uint = 0x5, + Uint = 0x6, [NativeName("Name", "WGPUTextureSampleType_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/ToneMappingMode.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/ToneMappingMode.gen.cs new file mode 100644 index 0000000000..1655b43fe3 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/ToneMappingMode.gen.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUToneMappingMode")] + public enum ToneMappingMode : int + { + [NativeName("Name", "WGPUToneMappingMode_Standard")] + Standard = 0x1, + [NativeName("Name", "WGPUToneMappingMode_Extended")] + Extended = 0x2, + [NativeName("Name", "WGPUToneMappingMode_Force32")] + Force32 = 0x7FFFFFFF, + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/VertexFormat.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/VertexFormat.gen.cs index 9eb4919dab..93853cef35 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/VertexFormat.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/VertexFormat.gen.cs @@ -12,68 +12,88 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUVertexFormat")] public enum VertexFormat : int { - [NativeName("Name", "WGPUVertexFormat_Undefined")] - Undefined = 0x0, + [NativeName("Name", "WGPUVertexFormat_Uint8")] + Uint8 = 0x1, [NativeName("Name", "WGPUVertexFormat_Uint8x2")] - Uint8x2 = 0x1, + Uint8x2 = 0x2, [NativeName("Name", "WGPUVertexFormat_Uint8x4")] - Uint8x4 = 0x2, + Uint8x4 = 0x3, + [NativeName("Name", "WGPUVertexFormat_Sint8")] + Sint8 = 0x4, [NativeName("Name", "WGPUVertexFormat_Sint8x2")] - Sint8x2 = 0x3, + Sint8x2 = 0x5, [NativeName("Name", "WGPUVertexFormat_Sint8x4")] - Sint8x4 = 0x4, + Sint8x4 = 0x6, + [NativeName("Name", "WGPUVertexFormat_Unorm8")] + Unorm8 = 0x7, [NativeName("Name", "WGPUVertexFormat_Unorm8x2")] - Unorm8x2 = 0x5, + Unorm8x2 = 0x8, [NativeName("Name", "WGPUVertexFormat_Unorm8x4")] - Unorm8x4 = 0x6, + Unorm8x4 = 0x9, + [NativeName("Name", "WGPUVertexFormat_Snorm8")] + Snorm8 = 0xA, [NativeName("Name", "WGPUVertexFormat_Snorm8x2")] - Snorm8x2 = 0x7, + Snorm8x2 = 0xB, [NativeName("Name", "WGPUVertexFormat_Snorm8x4")] - Snorm8x4 = 0x8, + Snorm8x4 = 0xC, + [NativeName("Name", "WGPUVertexFormat_Uint16")] + Uint16 = 0xD, [NativeName("Name", "WGPUVertexFormat_Uint16x2")] - Uint16x2 = 0x9, + Uint16x2 = 0xE, [NativeName("Name", "WGPUVertexFormat_Uint16x4")] - Uint16x4 = 0xA, + Uint16x4 = 0xF, + [NativeName("Name", "WGPUVertexFormat_Sint16")] + Sint16 = 0x10, [NativeName("Name", "WGPUVertexFormat_Sint16x2")] - Sint16x2 = 0xB, + Sint16x2 = 0x11, [NativeName("Name", "WGPUVertexFormat_Sint16x4")] - Sint16x4 = 0xC, + Sint16x4 = 0x12, + [NativeName("Name", "WGPUVertexFormat_Unorm16")] + Unorm16 = 0x13, [NativeName("Name", "WGPUVertexFormat_Unorm16x2")] - Unorm16x2 = 0xD, + Unorm16x2 = 0x14, [NativeName("Name", "WGPUVertexFormat_Unorm16x4")] - Unorm16x4 = 0xE, + Unorm16x4 = 0x15, + [NativeName("Name", "WGPUVertexFormat_Snorm16")] + Snorm16 = 0x16, [NativeName("Name", "WGPUVertexFormat_Snorm16x2")] - Snorm16x2 = 0xF, + Snorm16x2 = 0x17, [NativeName("Name", "WGPUVertexFormat_Snorm16x4")] - Snorm16x4 = 0x10, + Snorm16x4 = 0x18, + [NativeName("Name", "WGPUVertexFormat_Float16")] + Float16 = 0x19, [NativeName("Name", "WGPUVertexFormat_Float16x2")] - Float16x2 = 0x11, + Float16x2 = 0x1A, [NativeName("Name", "WGPUVertexFormat_Float16x4")] - Float16x4 = 0x12, + Float16x4 = 0x1B, [NativeName("Name", "WGPUVertexFormat_Float32")] - Float32 = 0x13, + Float32 = 0x1C, [NativeName("Name", "WGPUVertexFormat_Float32x2")] - Float32x2 = 0x14, + Float32x2 = 0x1D, [NativeName("Name", "WGPUVertexFormat_Float32x3")] - Float32x3 = 0x15, + Float32x3 = 0x1E, [NativeName("Name", "WGPUVertexFormat_Float32x4")] - Float32x4 = 0x16, + Float32x4 = 0x1F, [NativeName("Name", "WGPUVertexFormat_Uint32")] - Uint32 = 0x17, + Uint32 = 0x20, [NativeName("Name", "WGPUVertexFormat_Uint32x2")] - Uint32x2 = 0x18, + Uint32x2 = 0x21, [NativeName("Name", "WGPUVertexFormat_Uint32x3")] - Uint32x3 = 0x19, + Uint32x3 = 0x22, [NativeName("Name", "WGPUVertexFormat_Uint32x4")] - Uint32x4 = 0x1A, + Uint32x4 = 0x23, [NativeName("Name", "WGPUVertexFormat_Sint32")] - Sint32 = 0x1B, + Sint32 = 0x24, [NativeName("Name", "WGPUVertexFormat_Sint32x2")] - Sint32x2 = 0x1C, + Sint32x2 = 0x25, [NativeName("Name", "WGPUVertexFormat_Sint32x3")] - Sint32x3 = 0x1D, + Sint32x3 = 0x26, [NativeName("Name", "WGPUVertexFormat_Sint32x4")] - Sint32x4 = 0x1E, + Sint32x4 = 0x27, + [NativeName("Name", "WGPUVertexFormat_Unorm10_10_10_2")] + Unorm1010102 = 0x28, + [NativeName("Name", "WGPUVertexFormat_Unorm8x4BGRA")] + Unorm8x4Bgra = 0x29, [NativeName("Name", "WGPUVertexFormat_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/VertexStepMode.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/VertexStepMode.gen.cs index 4f318fbd89..10bc99bf0d 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Enums/VertexStepMode.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/VertexStepMode.gen.cs @@ -12,12 +12,12 @@ namespace Silk.NET.WebGPU [NativeName("Name", "WGPUVertexStepMode")] public enum VertexStepMode : int { + [NativeName("Name", "WGPUVertexStepMode_Undefined")] + Undefined = 0x0, [NativeName("Name", "WGPUVertexStepMode_Vertex")] - Vertex = 0x0, + Vertex = 0x1, [NativeName("Name", "WGPUVertexStepMode_Instance")] - Instance = 0x1, - [NativeName("Name", "WGPUVertexStepMode_VertexBufferNotUsed")] - VertexBufferNotUsed = 0x2, + Instance = 0x2, [NativeName("Name", "WGPUVertexStepMode_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Enums/WGSLLanguageFeatureName.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/WGSLLanguageFeatureName.gen.cs new file mode 100644 index 0000000000..5cd3983367 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/WGSLLanguageFeatureName.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUWGSLLanguageFeatureName")] + public enum WGSLLanguageFeatureName : int + { + [NativeName("Name", "WGPUWGSLLanguageFeatureName_ReadonlyAndReadwriteStorageTextures")] + ReadonlyAndReadwriteStorageTextures = 0x1, + [NativeName("Name", "WGPUWGSLLanguageFeatureName_Packed4x8IntegerDotProduct")] + Packed4x8integerDotProduct = 0x2, + [NativeName("Name", "WGPUWGSLLanguageFeatureName_UnrestrictedPointerParameters")] + UnrestrictedPointerParameters = 0x3, + [NativeName("Name", "WGPUWGSLLanguageFeatureName_PointerCompositeAccess")] + PointerCompositeAccess = 0x4, + [NativeName("Name", "WGPUWGSLLanguageFeatureName_Force32")] + Force32 = 0x7FFFFFFF, + } +} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/WaitStatus.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Enums/WaitStatus.gen.cs similarity index 51% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/WaitStatus.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Enums/WaitStatus.gen.cs index b50fd7163b..b6429fcb99 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Enums/WaitStatus.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Enums/WaitStatus.gen.cs @@ -7,23 +7,17 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUWaitStatus")] public enum WaitStatus : int { [NativeName("Name", "WGPUWaitStatus_Success")] - Success = 0x0, + Success = 0x1, [NativeName("Name", "WGPUWaitStatus_TimedOut")] - TimedOut = 0x1, - [NativeName("Name", "WGPUWaitStatus_UnsupportedTimeout")] - UnsupportedTimeout = 0x2, - [NativeName("Name", "WGPUWaitStatus_UnsupportedCount")] - UnsupportedCount = 0x3, - [NativeName("Name", "WGPUWaitStatus_UnsupportedMixedSources")] - UnsupportedMixedSources = 0x4, - [NativeName("Name", "WGPUWaitStatus_Unknown")] - Unknown = 0x5, + TimedOut = 0x2, + [NativeName("Name", "WGPUWaitStatus_Error")] + Error = 0x3, [NativeName("Name", "WGPUWaitStatus_Force32")] Force32 = 0x7FFFFFFF, } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/AdapterInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/AdapterInfo.gen.cs index 1427f5e111..004726ab74 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/AdapterInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/AdapterInfo.gen.cs @@ -21,52 +21,129 @@ public unsafe partial struct AdapterInfo { public AdapterInfo ( - byte* vendor = null, - byte* architecture = null, - byte* device = null, - byte* description = null + ChainedStruct* nextInChain = null, + StringView? vendor = null, + StringView? architecture = null, + StringView? device = null, + StringView? description = null, + BackendType? backendType = null, + AdapterType? adapterType = null, + uint? vendorID = null, + uint? deviceID = null, + uint? subgroupMinSize = null, + uint? subgroupMaxSize = null ) : this() { + if (nextInChain is not null) + { + NextInChain = nextInChain; + } + if (vendor is not null) { - Vendor = vendor; + Vendor = vendor.Value; } if (architecture is not null) { - Architecture = architecture; + Architecture = architecture.Value; } if (device is not null) { - Device = device; + Device = device.Value; } if (description is not null) { - Description = description; + Description = description.Value; + } + + if (backendType is not null) + { + BackendType = backendType.Value; + } + + if (adapterType is not null) + { + AdapterType = adapterType.Value; + } + + if (vendorID is not null) + { + VendorID = vendorID.Value; + } + + if (deviceID is not null) + { + DeviceID = deviceID.Value; + } + + if (subgroupMinSize is not null) + { + SubgroupMinSize = subgroupMinSize.Value; + } + + if (subgroupMaxSize is not null) + { + SubgroupMaxSize = subgroupMaxSize.Value; } } - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] + [NativeName("Name", "nextInChain")] + public ChainedStruct* NextInChain; + + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "vendor")] - public byte* Vendor; + public StringView Vendor; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "architecture")] - public byte* Architecture; + public StringView Architecture; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "device")] - public byte* Device; + public StringView Device; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "description")] - public byte* Description; + public StringView Description; + + [NativeName("Type", "WGPUBackendType")] + [NativeName("Type.Name", "WGPUBackendType")] + [NativeName("Name", "backendType")] + public BackendType BackendType; + + [NativeName("Type", "WGPUAdapterType")] + [NativeName("Type.Name", "WGPUAdapterType")] + [NativeName("Name", "adapterType")] + public AdapterType AdapterType; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "vendorID")] + public uint VendorID; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "deviceID")] + public uint DeviceID; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "subgroupMinSize")] + public uint SubgroupMinSize; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "subgroupMaxSize")] + public uint SubgroupMaxSize; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupDescriptor.gen.cs index 96261b4e8f..c1348b5f7e 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupDescriptor.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct BindGroupDescriptor public BindGroupDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, + StringView? label = null, BindGroupLayout* layout = null, nuint? entryCount = null, BindGroupEntry* entries = null @@ -35,7 +35,7 @@ public BindGroupDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (layout is not null) @@ -55,15 +55,15 @@ public BindGroupDescriptor } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; [NativeName("Type", "WGPUBindGroupLayout")] [NativeName("Type.Name", "WGPUBindGroupLayout")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupEntry.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupEntry.gen.cs index d535a71d50..01af04bf39 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupEntry.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupEntry.gen.cs @@ -67,8 +67,8 @@ public BindGroupEntry } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupLayoutDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupLayoutDescriptor.gen.cs index de883da6c5..94469a7b89 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupLayoutDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupLayoutDescriptor.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct BindGroupLayoutDescriptor public BindGroupLayoutDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, + StringView? label = null, nuint? entryCount = null, BindGroupLayoutEntry* entries = null ) : this() @@ -34,7 +34,7 @@ public BindGroupLayoutDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (entryCount is not null) @@ -49,15 +49,15 @@ public BindGroupLayoutDescriptor } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; [NativeName("Type", "size_t")] [NativeName("Type.Name", "size_t")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupLayoutEntry.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupLayoutEntry.gen.cs index 65cdcdec40..0ce385f3fd 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupLayoutEntry.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/BindGroupLayoutEntry.gen.cs @@ -23,7 +23,8 @@ public BindGroupLayoutEntry ( ChainedStruct* nextInChain = null, uint? binding = null, - Silk.NET.WebGPU.ShaderStage? visibility = null, + ulong? visibility = null, + uint? bindingArraySize = null, BufferBindingLayout? buffer = null, SamplerBindingLayout? sampler = null, TextureBindingLayout? texture = null, @@ -45,6 +46,11 @@ public BindGroupLayoutEntry Visibility = visibility.Value; } + if (bindingArraySize is not null) + { + BindingArraySize = bindingArraySize.Value; + } + if (buffer is not null) { Buffer = buffer.Value; @@ -67,8 +73,8 @@ public BindGroupLayoutEntry } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -77,10 +83,15 @@ public BindGroupLayoutEntry [NativeName("Name", "binding")] public uint Binding; - [NativeName("Type", "WGPUShaderStageFlags")] - [NativeName("Type.Name", "WGPUShaderStageFlags")] + [NativeName("Type", "WGPUShaderStage")] + [NativeName("Type.Name", "WGPUShaderStage")] [NativeName("Name", "visibility")] - public Silk.NET.WebGPU.ShaderStage Visibility; + public ulong Visibility; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "bindingArraySize")] + public uint BindingArraySize; [NativeName("Type", "WGPUBufferBindingLayout")] [NativeName("Type.Name", "WGPUBufferBindingLayout")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/BufferBindingLayout.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/BufferBindingLayout.gen.cs index c0dad6ef50..91ccbd152f 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/BufferBindingLayout.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/BufferBindingLayout.gen.cs @@ -49,8 +49,8 @@ public BufferBindingLayout } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/BufferDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/BufferDescriptor.gen.cs index e6585bce1b..5467b88cd0 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/BufferDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/BufferDescriptor.gen.cs @@ -22,8 +22,8 @@ public unsafe partial struct BufferDescriptor public BufferDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, - Silk.NET.WebGPU.BufferUsage? usage = null, + StringView? label = null, + ulong? usage = null, ulong? size = null, Silk.NET.Core.Bool32? mappedAtCreation = null ) : this() @@ -35,7 +35,7 @@ public BufferDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (usage is not null) @@ -55,20 +55,20 @@ public BufferDescriptor } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; - [NativeName("Type", "WGPUBufferUsageFlags")] - [NativeName("Type.Name", "WGPUBufferUsageFlags")] + [NativeName("Type", "WGPUBufferUsage")] + [NativeName("Type.Name", "WGPUBufferUsage")] [NativeName("Name", "usage")] - public Silk.NET.WebGPU.BufferUsage Usage; + public ulong Usage; [NativeName("Type", "uint64_t")] [NativeName("Type.Name", "uint64_t")] diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/BufferMapCallbackInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/BufferMapCallbackInfo.gen.cs similarity index 72% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/BufferMapCallbackInfo.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/BufferMapCallbackInfo.gen.cs index 9e85ea31a9..52e25767b6 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/BufferMapCallbackInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/BufferMapCallbackInfo.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUBufferMapCallbackInfo")] public unsafe partial struct BufferMapCallbackInfo @@ -24,7 +24,8 @@ public BufferMapCallbackInfo ChainedStruct* nextInChain = null, CallbackMode? mode = null, PfnBufferMapCallback? callback = null, - void* userdata = null + void* userdata1 = null, + void* userdata2 = null ) : this() { if (nextInChain is not null) @@ -42,15 +43,20 @@ public BufferMapCallbackInfo Callback = callback.Value; } - if (userdata is not null) + if (userdata1 is not null) { - Userdata = userdata; + Userdata1 = userdata1; + } + + if (userdata2 is not null) + { + Userdata2 = userdata2; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -66,7 +72,12 @@ public BufferMapCallbackInfo [NativeName("Type", "void *")] [NativeName("Type.Name", "void *")] - [NativeName("Name", "userdata")] - public void* Userdata; + [NativeName("Name", "userdata1")] + public void* Userdata1; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "userdata2")] + public void* Userdata2; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ChainedStruct.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/ChainedStruct.gen.cs index 9f6f848737..2b967d4711 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ChainedStruct.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/ChainedStruct.gen.cs @@ -37,8 +37,8 @@ public ChainedStruct } - [NativeName("Type", "const struct WGPUChainedStruct *")] - [NativeName("Type.Name", "const struct WGPUChainedStruct *")] + [NativeName("Type", "struct WGPUChainedStruct *")] + [NativeName("Type.Name", "struct WGPUChainedStruct *")] [NativeName("Name", "next")] public ChainedStruct* Next; diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ColorTargetState.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/ColorTargetState.gen.cs index 9ac7c5e3bb..0ec6378d4d 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ColorTargetState.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/ColorTargetState.gen.cs @@ -24,7 +24,7 @@ public ColorTargetState ChainedStruct* nextInChain = null, TextureFormat? format = null, BlendState* blend = null, - Silk.NET.WebGPU.ColorWriteMask? writeMask = null + ulong? writeMask = null ) : this() { if (nextInChain is not null) @@ -49,8 +49,8 @@ public ColorTargetState } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -64,9 +64,9 @@ public ColorTargetState [NativeName("Name", "blend")] public BlendState* Blend; - [NativeName("Type", "WGPUColorWriteMaskFlags")] - [NativeName("Type.Name", "WGPUColorWriteMaskFlags")] + [NativeName("Type", "WGPUColorWriteMask")] + [NativeName("Type.Name", "WGPUColorWriteMask")] [NativeName("Name", "writeMask")] - public Silk.NET.WebGPU.ColorWriteMask WriteMask; + public ulong WriteMask; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/CommandBufferDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/CommandBufferDescriptor.gen.cs index 34943fbc01..6106238e85 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/CommandBufferDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/CommandBufferDescriptor.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct CommandBufferDescriptor public CommandBufferDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null + StringView? label = null ) : this() { if (nextInChain is not null) @@ -32,19 +32,19 @@ public CommandBufferDescriptor if (label is not null) { - Label = label; + Label = label.Value; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/CommandEncoderDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/CommandEncoderDescriptor.gen.cs index 3071c1ce81..f695ac6b17 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/CommandEncoderDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/CommandEncoderDescriptor.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct CommandEncoderDescriptor public CommandEncoderDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null + StringView? label = null ) : this() { if (nextInChain is not null) @@ -32,19 +32,19 @@ public CommandEncoderDescriptor if (label is not null) { - Label = label; + Label = label.Value; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/CompilationInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/CompilationInfo.gen.cs index 12f062cd1e..dc6c187d04 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/CompilationInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/CompilationInfo.gen.cs @@ -43,8 +43,8 @@ public CompilationInfo } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/CompilationInfoCallbackInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/CompilationInfoCallbackInfo.gen.cs similarity index 73% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/CompilationInfoCallbackInfo.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/CompilationInfoCallbackInfo.gen.cs index cf96d8fc23..4ec3015003 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/CompilationInfoCallbackInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/CompilationInfoCallbackInfo.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUCompilationInfoCallbackInfo")] public unsafe partial struct CompilationInfoCallbackInfo @@ -24,7 +24,8 @@ public CompilationInfoCallbackInfo ChainedStruct* nextInChain = null, CallbackMode? mode = null, PfnCompilationInfoCallback? callback = null, - void* userdata = null + void* userdata1 = null, + void* userdata2 = null ) : this() { if (nextInChain is not null) @@ -42,15 +43,20 @@ public CompilationInfoCallbackInfo Callback = callback.Value; } - if (userdata is not null) + if (userdata1 is not null) { - Userdata = userdata; + Userdata1 = userdata1; + } + + if (userdata2 is not null) + { + Userdata2 = userdata2; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -66,7 +72,12 @@ public CompilationInfoCallbackInfo [NativeName("Type", "void *")] [NativeName("Type.Name", "void *")] - [NativeName("Name", "userdata")] - public void* Userdata; + [NativeName("Name", "userdata1")] + public void* Userdata1; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "userdata2")] + public void* Userdata2; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/CompilationMessage.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/CompilationMessage.gen.cs index cb4fe09b21..30ad926ab3 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/CompilationMessage.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/CompilationMessage.gen.cs @@ -22,15 +22,12 @@ public unsafe partial struct CompilationMessage public CompilationMessage ( ChainedStruct* nextInChain = null, - byte* message = null, + StringView? message = null, CompilationMessageType? type = null, ulong? lineNum = null, ulong? linePos = null, ulong? offset = null, - ulong? length = null, - ulong? utf16LinePos = null, - ulong? utf16Offset = null, - ulong? utf16Length = null + ulong? length = null ) : this() { if (nextInChain is not null) @@ -40,7 +37,7 @@ public CompilationMessage if (message is not null) { - Message = message; + Message = message.Value; } if (type is not null) @@ -67,33 +64,18 @@ public CompilationMessage { Length = length.Value; } - - if (utf16LinePos is not null) - { - Utf16LinePos = utf16LinePos.Value; - } - - if (utf16Offset is not null) - { - Utf16Offset = utf16Offset.Value; - } - - if (utf16Length is not null) - { - Utf16Length = utf16Length.Value; - } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "message")] - public byte* Message; + public StringView Message; [NativeName("Type", "WGPUCompilationMessageType")] [NativeName("Type.Name", "WGPUCompilationMessageType")] @@ -119,20 +101,5 @@ public CompilationMessage [NativeName("Type.Name", "uint64_t")] [NativeName("Name", "length")] public ulong Length; - - [NativeName("Type", "uint64_t")] - [NativeName("Type.Name", "uint64_t")] - [NativeName("Name", "utf16LinePos")] - public ulong Utf16LinePos; - - [NativeName("Type", "uint64_t")] - [NativeName("Type.Name", "uint64_t")] - [NativeName("Name", "utf16Offset")] - public ulong Utf16Offset; - - [NativeName("Type", "uint64_t")] - [NativeName("Type.Name", "uint64_t")] - [NativeName("Name", "utf16Length")] - public ulong Utf16Length; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ComputePassDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/ComputePassDescriptor.gen.cs index 56fd0c3a5c..62e7301345 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ComputePassDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/ComputePassDescriptor.gen.cs @@ -22,8 +22,8 @@ public unsafe partial struct ComputePassDescriptor public ComputePassDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, - ComputePassTimestampWrites* timestampWrites = null + StringView? label = null, + PassTimestampWrites* timestampWrites = null ) : this() { if (nextInChain is not null) @@ -33,7 +33,7 @@ public ComputePassDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (timestampWrites is not null) @@ -43,19 +43,19 @@ public ComputePassDescriptor } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; - [NativeName("Type", "const WGPUComputePassTimestampWrites *")] - [NativeName("Type.Name", "const WGPUComputePassTimestampWrites *")] + [NativeName("Type", "const WGPUPassTimestampWrites *")] + [NativeName("Type.Name", "const WGPUPassTimestampWrites *")] [NativeName("Name", "timestampWrites")] - public ComputePassTimestampWrites* TimestampWrites; + public PassTimestampWrites* TimestampWrites; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ComputePipelineDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/ComputePipelineDescriptor.gen.cs index 66674ae33f..e00a5a9e3a 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ComputePipelineDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/ComputePipelineDescriptor.gen.cs @@ -22,9 +22,9 @@ public unsafe partial struct ComputePipelineDescriptor public ComputePipelineDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, + StringView? label = null, PipelineLayout* layout = null, - ProgrammableStageDescriptor? compute = null + ComputeState? compute = null ) : this() { if (nextInChain is not null) @@ -34,7 +34,7 @@ public ComputePipelineDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (layout is not null) @@ -49,24 +49,24 @@ public ComputePipelineDescriptor } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; [NativeName("Type", "WGPUPipelineLayout")] [NativeName("Type.Name", "WGPUPipelineLayout")] [NativeName("Name", "layout")] public PipelineLayout* Layout; - [NativeName("Type", "WGPUProgrammableStageDescriptor")] - [NativeName("Type.Name", "WGPUProgrammableStageDescriptor")] + [NativeName("Type", "WGPUComputeState")] + [NativeName("Type.Name", "WGPUComputeState")] [NativeName("Name", "compute")] - public ProgrammableStageDescriptor Compute; + public ComputeState Compute; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ComputeState.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/ComputeState.gen.cs new file mode 100644 index 0000000000..3335d07ac1 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/ComputeState.gen.cs @@ -0,0 +1,83 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUComputeState")] + public unsafe partial struct ComputeState + { + public ComputeState + ( + ChainedStruct* nextInChain = null, + ShaderModule* module = null, + StringView? entryPoint = null, + nuint? constantCount = null, + ConstantEntry* constants = null + ) : this() + { + if (nextInChain is not null) + { + NextInChain = nextInChain; + } + + if (module is not null) + { + Module = module; + } + + if (entryPoint is not null) + { + EntryPoint = entryPoint.Value; + } + + if (constantCount is not null) + { + ConstantCount = constantCount.Value; + } + + if (constants is not null) + { + Constants = constants; + } + } + + + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] + [NativeName("Name", "nextInChain")] + public ChainedStruct* NextInChain; + + [NativeName("Type", "WGPUShaderModule")] + [NativeName("Type.Name", "WGPUShaderModule")] + [NativeName("Name", "module")] + public ShaderModule* Module; + + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] + [NativeName("Name", "entryPoint")] + public StringView EntryPoint; + + [NativeName("Type", "size_t")] + [NativeName("Type.Name", "size_t")] + [NativeName("Name", "constantCount")] + public nuint ConstantCount; + + [NativeName("Type", "const WGPUConstantEntry *")] + [NativeName("Type.Name", "const WGPUConstantEntry *")] + [NativeName("Name", "constants")] + public ConstantEntry* Constants; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ConstantEntry.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/ConstantEntry.gen.cs index d4bf6ad8a7..7959b38514 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ConstantEntry.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/ConstantEntry.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct ConstantEntry public ConstantEntry ( ChainedStruct* nextInChain = null, - byte* key = null, + StringView? key = null, double? value = null ) : this() { @@ -33,7 +33,7 @@ public ConstantEntry if (key is not null) { - Key = key; + Key = key.Value; } if (value is not null) @@ -43,15 +43,15 @@ public ConstantEntry } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "key")] - public byte* Key; + public StringView Key; [NativeName("Type", "double")] [NativeName("Type.Name", "double")] diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/CreateComputePipelineAsyncCallbackInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/CreateComputePipelineAsyncCallbackInfo.gen.cs similarity index 74% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/CreateComputePipelineAsyncCallbackInfo.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/CreateComputePipelineAsyncCallbackInfo.gen.cs index 3339d5965c..43438a9692 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/CreateComputePipelineAsyncCallbackInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/CreateComputePipelineAsyncCallbackInfo.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUCreateComputePipelineAsyncCallbackInfo")] public unsafe partial struct CreateComputePipelineAsyncCallbackInfo @@ -24,7 +24,8 @@ public CreateComputePipelineAsyncCallbackInfo ChainedStruct* nextInChain = null, CallbackMode? mode = null, PfnCreateComputePipelineAsyncCallback? callback = null, - void* userdata = null + void* userdata1 = null, + void* userdata2 = null ) : this() { if (nextInChain is not null) @@ -42,15 +43,20 @@ public CreateComputePipelineAsyncCallbackInfo Callback = callback.Value; } - if (userdata is not null) + if (userdata1 is not null) { - Userdata = userdata; + Userdata1 = userdata1; + } + + if (userdata2 is not null) + { + Userdata2 = userdata2; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -66,7 +72,12 @@ public CreateComputePipelineAsyncCallbackInfo [NativeName("Type", "void *")] [NativeName("Type.Name", "void *")] - [NativeName("Name", "userdata")] - public void* Userdata; + [NativeName("Name", "userdata1")] + public void* Userdata1; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "userdata2")] + public void* Userdata2; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/CreateRenderPipelineAsyncCallbackInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/CreateRenderPipelineAsyncCallbackInfo.gen.cs similarity index 74% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/CreateRenderPipelineAsyncCallbackInfo.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/CreateRenderPipelineAsyncCallbackInfo.gen.cs index ef0bff5ebe..db63ff955a 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/CreateRenderPipelineAsyncCallbackInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/CreateRenderPipelineAsyncCallbackInfo.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUCreateRenderPipelineAsyncCallbackInfo")] public unsafe partial struct CreateRenderPipelineAsyncCallbackInfo @@ -24,7 +24,8 @@ public CreateRenderPipelineAsyncCallbackInfo ChainedStruct* nextInChain = null, CallbackMode? mode = null, PfnCreateRenderPipelineAsyncCallback? callback = null, - void* userdata = null + void* userdata1 = null, + void* userdata2 = null ) : this() { if (nextInChain is not null) @@ -42,15 +43,20 @@ public CreateRenderPipelineAsyncCallbackInfo Callback = callback.Value; } - if (userdata is not null) + if (userdata1 is not null) { - Userdata = userdata; + Userdata1 = userdata1; + } + + if (userdata2 is not null) + { + Userdata2 = userdata2; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -66,7 +72,12 @@ public CreateRenderPipelineAsyncCallbackInfo [NativeName("Type", "void *")] [NativeName("Type.Name", "void *")] - [NativeName("Name", "userdata")] - public void* Userdata; + [NativeName("Name", "userdata1")] + public void* Userdata1; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "userdata2")] + public void* Userdata2; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/DepthStencilState.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/DepthStencilState.gen.cs index 674c893b70..9a8947bddf 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/DepthStencilState.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/DepthStencilState.gen.cs @@ -23,7 +23,7 @@ public DepthStencilState ( ChainedStruct* nextInChain = null, TextureFormat? format = null, - Silk.NET.Core.Bool32? depthWriteEnabled = null, + OptionalBool? depthWriteEnabled = null, CompareFunction? depthCompare = null, StencilFaceState? stencilFront = null, StencilFaceState? stencilBack = null, @@ -91,8 +91,8 @@ public DepthStencilState } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -101,10 +101,10 @@ public DepthStencilState [NativeName("Name", "format")] public TextureFormat Format; - [NativeName("Type", "WGPUBool")] - [NativeName("Type.Name", "WGPUBool")] + [NativeName("Type", "WGPUOptionalBool")] + [NativeName("Type.Name", "WGPUOptionalBool")] [NativeName("Name", "depthWriteEnabled")] - public Silk.NET.Core.Bool32 DepthWriteEnabled; + public OptionalBool DepthWriteEnabled; [NativeName("Type", "WGPUCompareFunction")] [NativeName("Type.Name", "WGPUCompareFunction")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/DeviceDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/DeviceDescriptor.gen.cs index 149f80fcce..e4c92cf290 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/DeviceDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/DeviceDescriptor.gen.cs @@ -22,13 +22,13 @@ public unsafe partial struct DeviceDescriptor public DeviceDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, + StringView? label = null, nuint? requiredFeatureCount = null, FeatureName* requiredFeatures = null, - RequiredLimits* requiredLimits = null, + Limits* requiredLimits = null, QueueDescriptor? defaultQueue = null, - PfnDeviceLostCallback? deviceLostCallback = null, - void* deviceLostUserdata = null + DeviceLostCallbackInfo? deviceLostCallbackInfo = null, + UncapturedErrorCallbackInfo? uncapturedErrorCallbackInfo = null ) : this() { if (nextInChain is not null) @@ -38,7 +38,7 @@ public DeviceDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (requiredFeatureCount is not null) @@ -61,27 +61,27 @@ public DeviceDescriptor DefaultQueue = defaultQueue.Value; } - if (deviceLostCallback is not null) + if (deviceLostCallbackInfo is not null) { - DeviceLostCallback = deviceLostCallback.Value; + DeviceLostCallbackInfo = deviceLostCallbackInfo.Value; } - if (deviceLostUserdata is not null) + if (uncapturedErrorCallbackInfo is not null) { - DeviceLostUserdata = deviceLostUserdata; + UncapturedErrorCallbackInfo = uncapturedErrorCallbackInfo.Value; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; [NativeName("Type", "size_t")] [NativeName("Type.Name", "size_t")] @@ -93,24 +93,24 @@ public DeviceDescriptor [NativeName("Name", "requiredFeatures")] public FeatureName* RequiredFeatures; - [NativeName("Type", "const WGPURequiredLimits *")] - [NativeName("Type.Name", "const WGPURequiredLimits *")] + [NativeName("Type", "const WGPULimits *")] + [NativeName("Type.Name", "const WGPULimits *")] [NativeName("Name", "requiredLimits")] - public RequiredLimits* RequiredLimits; + public Limits* RequiredLimits; [NativeName("Type", "WGPUQueueDescriptor")] [NativeName("Type.Name", "WGPUQueueDescriptor")] [NativeName("Name", "defaultQueue")] public QueueDescriptor DefaultQueue; - [NativeName("Type", "WGPUDeviceLostCallback")] - [NativeName("Type.Name", "WGPUDeviceLostCallback")] - [NativeName("Name", "deviceLostCallback")] - public PfnDeviceLostCallback DeviceLostCallback; + [NativeName("Type", "WGPUDeviceLostCallbackInfo")] + [NativeName("Type.Name", "WGPUDeviceLostCallbackInfo")] + [NativeName("Name", "deviceLostCallbackInfo")] + public DeviceLostCallbackInfo DeviceLostCallbackInfo; - [NativeName("Type", "void *")] - [NativeName("Type.Name", "void *")] - [NativeName("Name", "deviceLostUserdata")] - public void* DeviceLostUserdata; + [NativeName("Type", "WGPUUncapturedErrorCallbackInfo")] + [NativeName("Type.Name", "WGPUUncapturedErrorCallbackInfo")] + [NativeName("Name", "uncapturedErrorCallbackInfo")] + public UncapturedErrorCallbackInfo UncapturedErrorCallbackInfo; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/DeviceLostCallbackInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/DeviceLostCallbackInfo.gen.cs similarity index 63% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/DeviceLostCallbackInfo.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/DeviceLostCallbackInfo.gen.cs index 50a27c5e7f..2ff2109f64 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/DeviceLostCallbackInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/DeviceLostCallbackInfo.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUDeviceLostCallbackInfo")] public unsafe partial struct DeviceLostCallbackInfo @@ -23,8 +23,9 @@ public DeviceLostCallbackInfo ( ChainedStruct* nextInChain = null, CallbackMode? mode = null, - PfnDeviceLostCallbackNew? callback = null, - void* userdata = null + PfnDeviceLostCallback? callback = null, + void* userdata1 = null, + void* userdata2 = null ) : this() { if (nextInChain is not null) @@ -42,15 +43,20 @@ public DeviceLostCallbackInfo Callback = callback.Value; } - if (userdata is not null) + if (userdata1 is not null) { - Userdata = userdata; + Userdata1 = userdata1; + } + + if (userdata2 is not null) + { + Userdata2 = userdata2; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -59,14 +65,19 @@ public DeviceLostCallbackInfo [NativeName("Name", "mode")] public CallbackMode Mode; - [NativeName("Type", "WGPUDeviceLostCallbackNew")] - [NativeName("Type.Name", "WGPUDeviceLostCallbackNew")] + [NativeName("Type", "WGPUDeviceLostCallback")] + [NativeName("Type.Name", "WGPUDeviceLostCallback")] [NativeName("Name", "callback")] - public PfnDeviceLostCallbackNew Callback; + public PfnDeviceLostCallback Callback; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "userdata1")] + public void* Userdata1; [NativeName("Type", "void *")] [NativeName("Type.Name", "void *")] - [NativeName("Name", "userdata")] - public void* Userdata; + [NativeName("Name", "userdata2")] + public void* Userdata2; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/FragmentState.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/FragmentState.gen.cs index aef5e390f1..687c25de8e 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/FragmentState.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/FragmentState.gen.cs @@ -23,7 +23,7 @@ public FragmentState ( ChainedStruct* nextInChain = null, ShaderModule* module = null, - byte* entryPoint = null, + StringView? entryPoint = null, nuint? constantCount = null, ConstantEntry* constants = null, nuint? targetCount = null, @@ -42,7 +42,7 @@ public FragmentState if (entryPoint is not null) { - EntryPoint = entryPoint; + EntryPoint = entryPoint.Value; } if (constantCount is not null) @@ -67,8 +67,8 @@ public FragmentState } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -77,10 +77,10 @@ public FragmentState [NativeName("Name", "module")] public ShaderModule* Module; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "entryPoint")] - public byte* EntryPoint; + public StringView EntryPoint; [NativeName("Type", "size_t")] [NativeName("Type.Name", "size_t")] diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/Future.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/Future.gen.cs similarity index 95% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/Future.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/Future.gen.cs index 94c2637495..65b8d5743c 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/Future.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/Future.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUFuture")] public unsafe partial struct Future diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/FutureWaitInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/FutureWaitInfo.gen.cs similarity index 96% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/FutureWaitInfo.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/FutureWaitInfo.gen.cs index d005af0642..f79d11ffd0 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/FutureWaitInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/FutureWaitInfo.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUFutureWaitInfo")] public unsafe partial struct FutureWaitInfo diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/InstanceDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/InstanceDescriptor.gen.cs index e219bb3b16..f71e729f87 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/InstanceDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/InstanceDescriptor.gen.cs @@ -21,19 +21,52 @@ public unsafe partial struct InstanceDescriptor { public InstanceDescriptor ( - ChainedStruct* nextInChain = null + ChainedStruct* nextInChain = null, + nuint? requiredFeatureCount = null, + InstanceFeatureName* requiredFeatures = null, + InstanceLimits* requiredLimits = null ) : this() { if (nextInChain is not null) { NextInChain = nextInChain; } + + if (requiredFeatureCount is not null) + { + RequiredFeatureCount = requiredFeatureCount.Value; + } + + if (requiredFeatures is not null) + { + RequiredFeatures = requiredFeatures; + } + + if (requiredLimits is not null) + { + RequiredLimits = requiredLimits; + } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; + + [NativeName("Type", "size_t")] + [NativeName("Type.Name", "size_t")] + [NativeName("Name", "requiredFeatureCount")] + public nuint RequiredFeatureCount; + + [NativeName("Type", "const WGPUInstanceFeatureName *")] + [NativeName("Type.Name", "const WGPUInstanceFeatureName *")] + [NativeName("Name", "requiredFeatures")] + public InstanceFeatureName* RequiredFeatures; + + [NativeName("Type", "const WGPUInstanceLimits *")] + [NativeName("Type.Name", "const WGPUInstanceLimits *")] + [NativeName("Name", "requiredLimits")] + public InstanceLimits* RequiredLimits; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/InstanceLimits.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/InstanceLimits.gen.cs new file mode 100644 index 0000000000..5caf037b0a --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/InstanceLimits.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUInstanceLimits")] + public unsafe partial struct InstanceLimits + { + public InstanceLimits + ( + ChainedStruct* nextInChain = null, + nuint? timedWaitAnyMaxCount = null + ) : this() + { + if (nextInChain is not null) + { + NextInChain = nextInChain; + } + + if (timedWaitAnyMaxCount is not null) + { + TimedWaitAnyMaxCount = timedWaitAnyMaxCount.Value; + } + } + + + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] + [NativeName("Name", "nextInChain")] + public ChainedStruct* NextInChain; + + [NativeName("Type", "size_t")] + [NativeName("Type.Name", "size_t")] + [NativeName("Name", "timedWaitAnyMaxCount")] + public nuint TimedWaitAnyMaxCount; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/Limits.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/Limits.gen.cs index ec432734e9..b225380d85 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/Limits.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/Limits.gen.cs @@ -21,6 +21,7 @@ public unsafe partial struct Limits { public Limits ( + ChainedStruct* nextInChain = null, uint? maxTextureDimension1D = null, uint? maxTextureDimension2D = null, uint? maxTextureDimension3D = null, @@ -43,7 +44,6 @@ public Limits ulong? maxBufferSize = null, uint? maxVertexAttributes = null, uint? maxVertexBufferArrayStride = null, - uint? maxInterStageShaderComponents = null, uint? maxInterStageShaderVariables = null, uint? maxColorAttachments = null, uint? maxColorAttachmentBytesPerSample = null, @@ -52,9 +52,15 @@ public Limits uint? maxComputeWorkgroupSizeX = null, uint? maxComputeWorkgroupSizeY = null, uint? maxComputeWorkgroupSizeZ = null, - uint? maxComputeWorkgroupsPerDimension = null + uint? maxComputeWorkgroupsPerDimension = null, + uint? maxImmediateSize = null ) : this() { + if (nextInChain is not null) + { + NextInChain = nextInChain; + } + if (maxTextureDimension1D is not null) { MaxTextureDimension1D = maxTextureDimension1D.Value; @@ -165,11 +171,6 @@ public Limits MaxVertexBufferArrayStride = maxVertexBufferArrayStride.Value; } - if (maxInterStageShaderComponents is not null) - { - MaxInterStageShaderComponents = maxInterStageShaderComponents.Value; - } - if (maxInterStageShaderVariables is not null) { MaxInterStageShaderVariables = maxInterStageShaderVariables.Value; @@ -214,9 +215,19 @@ public Limits { MaxComputeWorkgroupsPerDimension = maxComputeWorkgroupsPerDimension.Value; } + + if (maxImmediateSize is not null) + { + MaxImmediateSize = maxImmediateSize.Value; + } } + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] + [NativeName("Name", "nextInChain")] + public ChainedStruct* NextInChain; + [NativeName("Type", "uint32_t")] [NativeName("Type.Name", "uint32_t")] [NativeName("Name", "maxTextureDimension1D")] @@ -327,11 +338,6 @@ public Limits [NativeName("Name", "maxVertexBufferArrayStride")] public uint MaxVertexBufferArrayStride; - [NativeName("Type", "uint32_t")] - [NativeName("Type.Name", "uint32_t")] - [NativeName("Name", "maxInterStageShaderComponents")] - public uint MaxInterStageShaderComponents; - [NativeName("Type", "uint32_t")] [NativeName("Type.Name", "uint32_t")] [NativeName("Name", "maxInterStageShaderVariables")] @@ -376,5 +382,10 @@ public Limits [NativeName("Type.Name", "uint32_t")] [NativeName("Name", "maxComputeWorkgroupsPerDimension")] public uint MaxComputeWorkgroupsPerDimension; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "maxImmediateSize")] + public uint MaxImmediateSize; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/MultisampleState.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/MultisampleState.gen.cs index 4597b01d5b..9c1ab0e268 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/MultisampleState.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/MultisampleState.gen.cs @@ -49,8 +49,8 @@ public MultisampleState } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PassTimestampWrites.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PassTimestampWrites.gen.cs new file mode 100644 index 0000000000..b6621b6b3c --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PassTimestampWrites.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUPassTimestampWrites")] + public unsafe partial struct PassTimestampWrites + { + public PassTimestampWrites + ( + ChainedStruct* nextInChain = null, + QuerySet* querySet = null, + uint? beginningOfPassWriteIndex = null, + uint? endOfPassWriteIndex = null + ) : this() + { + if (nextInChain is not null) + { + NextInChain = nextInChain; + } + + if (querySet is not null) + { + QuerySet = querySet; + } + + if (beginningOfPassWriteIndex is not null) + { + BeginningOfPassWriteIndex = beginningOfPassWriteIndex.Value; + } + + if (endOfPassWriteIndex is not null) + { + EndOfPassWriteIndex = endOfPassWriteIndex.Value; + } + } + + + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] + [NativeName("Name", "nextInChain")] + public ChainedStruct* NextInChain; + + [NativeName("Type", "WGPUQuerySet")] + [NativeName("Type.Name", "WGPUQuerySet")] + [NativeName("Name", "querySet")] + public QuerySet* QuerySet; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "beginningOfPassWriteIndex")] + public uint BeginningOfPassWriteIndex; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "endOfPassWriteIndex")] + public uint EndOfPassWriteIndex; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnAdapterRequestAdapterInfoCallback.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnAdapterRequestAdapterInfoCallback.gen.cs deleted file mode 100644 index ae72b6f483..0000000000 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnAdapterRequestAdapterInfoCallback.gen.cs +++ /dev/null @@ -1,53 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using System.Runtime.InteropServices; -using System.Runtime.CompilerServices; -using System.Text; -using Silk.NET.Core; -using Silk.NET.Core.Native; -using Silk.NET.Core.Attributes; -using Silk.NET.Core.Contexts; -using Silk.NET.Core.Loader; - -#pragma warning disable 1591 - -namespace Silk.NET.WebGPU -{ - public unsafe readonly struct PfnAdapterRequestAdapterInfoCallback : IDisposable - { - private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; - public PfnAdapterRequestAdapterInfoCallback - ( - delegate* unmanaged[Cdecl] ptr - ) => _handle = ptr; - - public PfnAdapterRequestAdapterInfoCallback - ( - AdapterRequestAdapterInfoCallback proc - ) => _handle = (void*) SilkMarshal.DelegateToPtr(proc); - - public static PfnAdapterRequestAdapterInfoCallback From(AdapterRequestAdapterInfoCallback proc) => new PfnAdapterRequestAdapterInfoCallback(proc); - public void Dispose() => SilkMarshal.Free((nint) _handle); - - public static implicit operator nint(PfnAdapterRequestAdapterInfoCallback pfn) => (nint) pfn.Handle; - public static explicit operator PfnAdapterRequestAdapterInfoCallback(nint pfn) - => new PfnAdapterRequestAdapterInfoCallback((delegate* unmanaged[Cdecl]) pfn); - - public static implicit operator PfnAdapterRequestAdapterInfoCallback(AdapterRequestAdapterInfoCallback proc) - => new PfnAdapterRequestAdapterInfoCallback(proc); - - public static explicit operator AdapterRequestAdapterInfoCallback(PfnAdapterRequestAdapterInfoCallback pfn) - => SilkMarshal.PtrToDelegate(pfn); - - public static implicit operator delegate* unmanaged[Cdecl](PfnAdapterRequestAdapterInfoCallback pfn) => pfn.Handle; - public static implicit operator PfnAdapterRequestAdapterInfoCallback(delegate* unmanaged[Cdecl] ptr) => new PfnAdapterRequestAdapterInfoCallback(ptr); - } - - [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate void AdapterRequestAdapterInfoCallback(AdapterInfo arg0, void* arg1); -} - diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnBufferMapCallback.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnBufferMapCallback.gen.cs index e56096e78d..945ca2392f 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnBufferMapCallback.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnBufferMapCallback.gen.cs @@ -19,10 +19,10 @@ namespace Silk.NET.WebGPU public unsafe readonly struct PfnBufferMapCallback : IDisposable { private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; public PfnBufferMapCallback ( - delegate* unmanaged[Cdecl] ptr + delegate* unmanaged[Cdecl] ptr ) => _handle = ptr; public PfnBufferMapCallback @@ -35,7 +35,7 @@ BufferMapCallback proc public static implicit operator nint(PfnBufferMapCallback pfn) => (nint) pfn.Handle; public static explicit operator PfnBufferMapCallback(nint pfn) - => new PfnBufferMapCallback((delegate* unmanaged[Cdecl]) pfn); + => new PfnBufferMapCallback((delegate* unmanaged[Cdecl]) pfn); public static implicit operator PfnBufferMapCallback(BufferMapCallback proc) => new PfnBufferMapCallback(proc); @@ -43,11 +43,11 @@ public static implicit operator PfnBufferMapCallback(BufferMapCallback proc) public static explicit operator BufferMapCallback(PfnBufferMapCallback pfn) => SilkMarshal.PtrToDelegate(pfn); - public static implicit operator delegate* unmanaged[Cdecl](PfnBufferMapCallback pfn) => pfn.Handle; - public static implicit operator PfnBufferMapCallback(delegate* unmanaged[Cdecl] ptr) => new PfnBufferMapCallback(ptr); + public static implicit operator delegate* unmanaged[Cdecl](PfnBufferMapCallback pfn) => pfn.Handle; + public static implicit operator PfnBufferMapCallback(delegate* unmanaged[Cdecl] ptr) => new PfnBufferMapCallback(ptr); } [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate void BufferMapCallback(BufferMapAsyncStatus arg0, void* arg1); + public unsafe delegate void BufferMapCallback(MapAsyncStatus arg0, StringView arg1, void* arg2, void* arg3); } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCompilationInfoCallback.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCompilationInfoCallback.gen.cs index f6df8e2b2b..7ad99e8e2f 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCompilationInfoCallback.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCompilationInfoCallback.gen.cs @@ -19,10 +19,10 @@ namespace Silk.NET.WebGPU public unsafe readonly struct PfnCompilationInfoCallback : IDisposable { private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; public PfnCompilationInfoCallback ( - delegate* unmanaged[Cdecl] ptr + delegate* unmanaged[Cdecl] ptr ) => _handle = ptr; public PfnCompilationInfoCallback @@ -35,7 +35,7 @@ CompilationInfoCallback proc public static implicit operator nint(PfnCompilationInfoCallback pfn) => (nint) pfn.Handle; public static explicit operator PfnCompilationInfoCallback(nint pfn) - => new PfnCompilationInfoCallback((delegate* unmanaged[Cdecl]) pfn); + => new PfnCompilationInfoCallback((delegate* unmanaged[Cdecl]) pfn); public static implicit operator PfnCompilationInfoCallback(CompilationInfoCallback proc) => new PfnCompilationInfoCallback(proc); @@ -43,11 +43,11 @@ public static implicit operator PfnCompilationInfoCallback(CompilationInfoCallba public static explicit operator CompilationInfoCallback(PfnCompilationInfoCallback pfn) => SilkMarshal.PtrToDelegate(pfn); - public static implicit operator delegate* unmanaged[Cdecl](PfnCompilationInfoCallback pfn) => pfn.Handle; - public static implicit operator PfnCompilationInfoCallback(delegate* unmanaged[Cdecl] ptr) => new PfnCompilationInfoCallback(ptr); + public static implicit operator delegate* unmanaged[Cdecl](PfnCompilationInfoCallback pfn) => pfn.Handle; + public static implicit operator PfnCompilationInfoCallback(delegate* unmanaged[Cdecl] ptr) => new PfnCompilationInfoCallback(ptr); } [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate void CompilationInfoCallback(CompilationInfoRequestStatus arg0, CompilationInfo* arg1, void* arg2); + public unsafe delegate void CompilationInfoCallback(CompilationInfoRequestStatus arg0, CompilationInfo* arg1, void* arg2, void* arg3); } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCreateComputePipelineAsyncCallback.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCreateComputePipelineAsyncCallback.gen.cs index 01b3b633d5..25d71d1348 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCreateComputePipelineAsyncCallback.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCreateComputePipelineAsyncCallback.gen.cs @@ -19,10 +19,10 @@ namespace Silk.NET.WebGPU public unsafe readonly struct PfnCreateComputePipelineAsyncCallback : IDisposable { private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; public PfnCreateComputePipelineAsyncCallback ( - delegate* unmanaged[Cdecl] ptr + delegate* unmanaged[Cdecl] ptr ) => _handle = ptr; public PfnCreateComputePipelineAsyncCallback @@ -35,7 +35,7 @@ CreateComputePipelineAsyncCallback proc public static implicit operator nint(PfnCreateComputePipelineAsyncCallback pfn) => (nint) pfn.Handle; public static explicit operator PfnCreateComputePipelineAsyncCallback(nint pfn) - => new PfnCreateComputePipelineAsyncCallback((delegate* unmanaged[Cdecl]) pfn); + => new PfnCreateComputePipelineAsyncCallback((delegate* unmanaged[Cdecl]) pfn); public static implicit operator PfnCreateComputePipelineAsyncCallback(CreateComputePipelineAsyncCallback proc) => new PfnCreateComputePipelineAsyncCallback(proc); @@ -43,11 +43,11 @@ public static implicit operator PfnCreateComputePipelineAsyncCallback(CreateComp public static explicit operator CreateComputePipelineAsyncCallback(PfnCreateComputePipelineAsyncCallback pfn) => SilkMarshal.PtrToDelegate(pfn); - public static implicit operator delegate* unmanaged[Cdecl](PfnCreateComputePipelineAsyncCallback pfn) => pfn.Handle; - public static implicit operator PfnCreateComputePipelineAsyncCallback(delegate* unmanaged[Cdecl] ptr) => new PfnCreateComputePipelineAsyncCallback(ptr); + public static implicit operator delegate* unmanaged[Cdecl](PfnCreateComputePipelineAsyncCallback pfn) => pfn.Handle; + public static implicit operator PfnCreateComputePipelineAsyncCallback(delegate* unmanaged[Cdecl] ptr) => new PfnCreateComputePipelineAsyncCallback(ptr); } [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate void CreateComputePipelineAsyncCallback(CreatePipelineAsyncStatus arg0, ComputePipeline* arg1, byte* arg2, void* arg3); + public unsafe delegate void CreateComputePipelineAsyncCallback(CreatePipelineAsyncStatus arg0, ComputePipeline* arg1, StringView arg2, void* arg3, void* arg4); } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCreateRenderPipelineAsyncCallback.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCreateRenderPipelineAsyncCallback.gen.cs index 388377e929..478acc2210 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCreateRenderPipelineAsyncCallback.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnCreateRenderPipelineAsyncCallback.gen.cs @@ -19,10 +19,10 @@ namespace Silk.NET.WebGPU public unsafe readonly struct PfnCreateRenderPipelineAsyncCallback : IDisposable { private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; public PfnCreateRenderPipelineAsyncCallback ( - delegate* unmanaged[Cdecl] ptr + delegate* unmanaged[Cdecl] ptr ) => _handle = ptr; public PfnCreateRenderPipelineAsyncCallback @@ -35,7 +35,7 @@ CreateRenderPipelineAsyncCallback proc public static implicit operator nint(PfnCreateRenderPipelineAsyncCallback pfn) => (nint) pfn.Handle; public static explicit operator PfnCreateRenderPipelineAsyncCallback(nint pfn) - => new PfnCreateRenderPipelineAsyncCallback((delegate* unmanaged[Cdecl]) pfn); + => new PfnCreateRenderPipelineAsyncCallback((delegate* unmanaged[Cdecl]) pfn); public static implicit operator PfnCreateRenderPipelineAsyncCallback(CreateRenderPipelineAsyncCallback proc) => new PfnCreateRenderPipelineAsyncCallback(proc); @@ -43,11 +43,11 @@ public static implicit operator PfnCreateRenderPipelineAsyncCallback(CreateRende public static explicit operator CreateRenderPipelineAsyncCallback(PfnCreateRenderPipelineAsyncCallback pfn) => SilkMarshal.PtrToDelegate(pfn); - public static implicit operator delegate* unmanaged[Cdecl](PfnCreateRenderPipelineAsyncCallback pfn) => pfn.Handle; - public static implicit operator PfnCreateRenderPipelineAsyncCallback(delegate* unmanaged[Cdecl] ptr) => new PfnCreateRenderPipelineAsyncCallback(ptr); + public static implicit operator delegate* unmanaged[Cdecl](PfnCreateRenderPipelineAsyncCallback pfn) => pfn.Handle; + public static implicit operator PfnCreateRenderPipelineAsyncCallback(delegate* unmanaged[Cdecl] ptr) => new PfnCreateRenderPipelineAsyncCallback(ptr); } [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate void CreateRenderPipelineAsyncCallback(CreatePipelineAsyncStatus arg0, RenderPipeline* arg1, byte* arg2, void* arg3); + public unsafe delegate void CreateRenderPipelineAsyncCallback(CreatePipelineAsyncStatus arg0, RenderPipeline* arg1, StringView arg2, void* arg3, void* arg4); } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnDeviceLostCallback.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnDeviceLostCallback.gen.cs index 29e4faa7b7..8af52ea7d3 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnDeviceLostCallback.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnDeviceLostCallback.gen.cs @@ -19,10 +19,10 @@ namespace Silk.NET.WebGPU public unsafe readonly struct PfnDeviceLostCallback : IDisposable { private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; public PfnDeviceLostCallback ( - delegate* unmanaged[Cdecl] ptr + delegate* unmanaged[Cdecl] ptr ) => _handle = ptr; public PfnDeviceLostCallback @@ -35,7 +35,7 @@ DeviceLostCallback proc public static implicit operator nint(PfnDeviceLostCallback pfn) => (nint) pfn.Handle; public static explicit operator PfnDeviceLostCallback(nint pfn) - => new PfnDeviceLostCallback((delegate* unmanaged[Cdecl]) pfn); + => new PfnDeviceLostCallback((delegate* unmanaged[Cdecl]) pfn); public static implicit operator PfnDeviceLostCallback(DeviceLostCallback proc) => new PfnDeviceLostCallback(proc); @@ -43,11 +43,11 @@ public static implicit operator PfnDeviceLostCallback(DeviceLostCallback proc) public static explicit operator DeviceLostCallback(PfnDeviceLostCallback pfn) => SilkMarshal.PtrToDelegate(pfn); - public static implicit operator delegate* unmanaged[Cdecl](PfnDeviceLostCallback pfn) => pfn.Handle; - public static implicit operator PfnDeviceLostCallback(delegate* unmanaged[Cdecl] ptr) => new PfnDeviceLostCallback(ptr); + public static implicit operator delegate* unmanaged[Cdecl](PfnDeviceLostCallback pfn) => pfn.Handle; + public static implicit operator PfnDeviceLostCallback(delegate* unmanaged[Cdecl] ptr) => new PfnDeviceLostCallback(ptr); } [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate void DeviceLostCallback(DeviceLostReason arg0, byte* arg1, void* arg2); + public unsafe delegate void DeviceLostCallback(Device** arg0, DeviceLostReason arg1, StringView arg2, void* arg3, void* arg4); } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PfnPopErrorScopeCallback.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnPopErrorScopeCallback.gen.cs similarity index 75% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PfnPopErrorScopeCallback.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/PfnPopErrorScopeCallback.gen.cs index 80da8d3bdf..3a597ceafa 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PfnPopErrorScopeCallback.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnPopErrorScopeCallback.gen.cs @@ -14,15 +14,15 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { public unsafe readonly struct PfnPopErrorScopeCallback : IDisposable { private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; public PfnPopErrorScopeCallback ( - delegate* unmanaged[Cdecl] ptr + delegate* unmanaged[Cdecl] ptr ) => _handle = ptr; public PfnPopErrorScopeCallback @@ -35,7 +35,7 @@ PopErrorScopeCallback proc public static implicit operator nint(PfnPopErrorScopeCallback pfn) => (nint) pfn.Handle; public static explicit operator PfnPopErrorScopeCallback(nint pfn) - => new PfnPopErrorScopeCallback((delegate* unmanaged[Cdecl]) pfn); + => new PfnPopErrorScopeCallback((delegate* unmanaged[Cdecl]) pfn); public static implicit operator PfnPopErrorScopeCallback(PopErrorScopeCallback proc) => new PfnPopErrorScopeCallback(proc); @@ -43,11 +43,11 @@ public static implicit operator PfnPopErrorScopeCallback(PopErrorScopeCallback p public static explicit operator PopErrorScopeCallback(PfnPopErrorScopeCallback pfn) => SilkMarshal.PtrToDelegate(pfn); - public static implicit operator delegate* unmanaged[Cdecl](PfnPopErrorScopeCallback pfn) => pfn.Handle; - public static implicit operator PfnPopErrorScopeCallback(delegate* unmanaged[Cdecl] ptr) => new PfnPopErrorScopeCallback(ptr); + public static implicit operator delegate* unmanaged[Cdecl](PfnPopErrorScopeCallback pfn) => pfn.Handle; + public static implicit operator PfnPopErrorScopeCallback(delegate* unmanaged[Cdecl] ptr) => new PfnPopErrorScopeCallback(ptr); } [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate void PopErrorScopeCallback(PopErrorScopeStatus arg0, ErrorType arg1, byte* arg2, void* arg3); + public unsafe delegate void PopErrorScopeCallback(PopErrorScopeStatus arg0, ErrorType arg1, StringView arg2, void* arg3, void* arg4); } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnQueueWorkDoneCallback.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnQueueWorkDoneCallback.gen.cs index 3fc3987744..a1e59cfbd3 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnQueueWorkDoneCallback.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnQueueWorkDoneCallback.gen.cs @@ -19,10 +19,10 @@ namespace Silk.NET.WebGPU public unsafe readonly struct PfnQueueWorkDoneCallback : IDisposable { private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; public PfnQueueWorkDoneCallback ( - delegate* unmanaged[Cdecl] ptr + delegate* unmanaged[Cdecl] ptr ) => _handle = ptr; public PfnQueueWorkDoneCallback @@ -35,7 +35,7 @@ QueueWorkDoneCallback proc public static implicit operator nint(PfnQueueWorkDoneCallback pfn) => (nint) pfn.Handle; public static explicit operator PfnQueueWorkDoneCallback(nint pfn) - => new PfnQueueWorkDoneCallback((delegate* unmanaged[Cdecl]) pfn); + => new PfnQueueWorkDoneCallback((delegate* unmanaged[Cdecl]) pfn); public static implicit operator PfnQueueWorkDoneCallback(QueueWorkDoneCallback proc) => new PfnQueueWorkDoneCallback(proc); @@ -43,11 +43,11 @@ public static implicit operator PfnQueueWorkDoneCallback(QueueWorkDoneCallback p public static explicit operator QueueWorkDoneCallback(PfnQueueWorkDoneCallback pfn) => SilkMarshal.PtrToDelegate(pfn); - public static implicit operator delegate* unmanaged[Cdecl](PfnQueueWorkDoneCallback pfn) => pfn.Handle; - public static implicit operator PfnQueueWorkDoneCallback(delegate* unmanaged[Cdecl] ptr) => new PfnQueueWorkDoneCallback(ptr); + public static implicit operator delegate* unmanaged[Cdecl](PfnQueueWorkDoneCallback pfn) => pfn.Handle; + public static implicit operator PfnQueueWorkDoneCallback(delegate* unmanaged[Cdecl] ptr) => new PfnQueueWorkDoneCallback(ptr); } [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate void QueueWorkDoneCallback(QueueWorkDoneStatus arg0, void* arg1); + public unsafe delegate void QueueWorkDoneCallback(QueueWorkDoneStatus arg0, StringView arg1, void* arg2, void* arg3); } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnRequestAdapterCallback.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnRequestAdapterCallback.gen.cs index bccdb93d83..e6ff151e2a 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnRequestAdapterCallback.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnRequestAdapterCallback.gen.cs @@ -19,10 +19,10 @@ namespace Silk.NET.WebGPU public unsafe readonly struct PfnRequestAdapterCallback : IDisposable { private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; public PfnRequestAdapterCallback ( - delegate* unmanaged[Cdecl] ptr + delegate* unmanaged[Cdecl] ptr ) => _handle = ptr; public PfnRequestAdapterCallback @@ -35,7 +35,7 @@ RequestAdapterCallback proc public static implicit operator nint(PfnRequestAdapterCallback pfn) => (nint) pfn.Handle; public static explicit operator PfnRequestAdapterCallback(nint pfn) - => new PfnRequestAdapterCallback((delegate* unmanaged[Cdecl]) pfn); + => new PfnRequestAdapterCallback((delegate* unmanaged[Cdecl]) pfn); public static implicit operator PfnRequestAdapterCallback(RequestAdapterCallback proc) => new PfnRequestAdapterCallback(proc); @@ -43,11 +43,11 @@ public static implicit operator PfnRequestAdapterCallback(RequestAdapterCallback public static explicit operator RequestAdapterCallback(PfnRequestAdapterCallback pfn) => SilkMarshal.PtrToDelegate(pfn); - public static implicit operator delegate* unmanaged[Cdecl](PfnRequestAdapterCallback pfn) => pfn.Handle; - public static implicit operator PfnRequestAdapterCallback(delegate* unmanaged[Cdecl] ptr) => new PfnRequestAdapterCallback(ptr); + public static implicit operator delegate* unmanaged[Cdecl](PfnRequestAdapterCallback pfn) => pfn.Handle; + public static implicit operator PfnRequestAdapterCallback(delegate* unmanaged[Cdecl] ptr) => new PfnRequestAdapterCallback(ptr); } [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate void RequestAdapterCallback(RequestAdapterStatus arg0, Adapter* arg1, byte* arg2, void* arg3); + public unsafe delegate void RequestAdapterCallback(RequestAdapterStatus arg0, Adapter* arg1, StringView arg2, void* arg3, void* arg4); } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnRequestDeviceCallback.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnRequestDeviceCallback.gen.cs index 0b5ec9ebf7..79c1e7f9ba 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnRequestDeviceCallback.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnRequestDeviceCallback.gen.cs @@ -19,10 +19,10 @@ namespace Silk.NET.WebGPU public unsafe readonly struct PfnRequestDeviceCallback : IDisposable { private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; public PfnRequestDeviceCallback ( - delegate* unmanaged[Cdecl] ptr + delegate* unmanaged[Cdecl] ptr ) => _handle = ptr; public PfnRequestDeviceCallback @@ -35,7 +35,7 @@ RequestDeviceCallback proc public static implicit operator nint(PfnRequestDeviceCallback pfn) => (nint) pfn.Handle; public static explicit operator PfnRequestDeviceCallback(nint pfn) - => new PfnRequestDeviceCallback((delegate* unmanaged[Cdecl]) pfn); + => new PfnRequestDeviceCallback((delegate* unmanaged[Cdecl]) pfn); public static implicit operator PfnRequestDeviceCallback(RequestDeviceCallback proc) => new PfnRequestDeviceCallback(proc); @@ -43,11 +43,11 @@ public static implicit operator PfnRequestDeviceCallback(RequestDeviceCallback p public static explicit operator RequestDeviceCallback(PfnRequestDeviceCallback pfn) => SilkMarshal.PtrToDelegate(pfn); - public static implicit operator delegate* unmanaged[Cdecl](PfnRequestDeviceCallback pfn) => pfn.Handle; - public static implicit operator PfnRequestDeviceCallback(delegate* unmanaged[Cdecl] ptr) => new PfnRequestDeviceCallback(ptr); + public static implicit operator delegate* unmanaged[Cdecl](PfnRequestDeviceCallback pfn) => pfn.Handle; + public static implicit operator PfnRequestDeviceCallback(delegate* unmanaged[Cdecl] ptr) => new PfnRequestDeviceCallback(ptr); } [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate void RequestDeviceCallback(RequestDeviceStatus arg0, Device* arg1, byte* arg2, void* arg3); + public unsafe delegate void RequestDeviceCallback(RequestDeviceStatus arg0, Device* arg1, StringView arg2, void* arg3, void* arg4); } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PfnUncapturedErrorCallback.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnUncapturedErrorCallback.gen.cs new file mode 100644 index 0000000000..0ca2899836 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PfnUncapturedErrorCallback.gen.cs @@ -0,0 +1,53 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + public unsafe readonly struct PfnUncapturedErrorCallback : IDisposable + { + private readonly void* _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public PfnUncapturedErrorCallback + ( + delegate* unmanaged[Cdecl] ptr + ) => _handle = ptr; + + public PfnUncapturedErrorCallback + ( + UncapturedErrorCallback proc + ) => _handle = (void*) SilkMarshal.DelegateToPtr(proc); + + public static PfnUncapturedErrorCallback From(UncapturedErrorCallback proc) => new PfnUncapturedErrorCallback(proc); + public void Dispose() => SilkMarshal.Free((nint) _handle); + + public static implicit operator nint(PfnUncapturedErrorCallback pfn) => (nint) pfn.Handle; + public static explicit operator PfnUncapturedErrorCallback(nint pfn) + => new PfnUncapturedErrorCallback((delegate* unmanaged[Cdecl]) pfn); + + public static implicit operator PfnUncapturedErrorCallback(UncapturedErrorCallback proc) + => new PfnUncapturedErrorCallback(proc); + + public static explicit operator UncapturedErrorCallback(PfnUncapturedErrorCallback pfn) + => SilkMarshal.PtrToDelegate(pfn); + + public static implicit operator delegate* unmanaged[Cdecl](PfnUncapturedErrorCallback pfn) => pfn.Handle; + public static implicit operator PfnUncapturedErrorCallback(delegate* unmanaged[Cdecl] ptr) => new PfnUncapturedErrorCallback(ptr); + } + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void UncapturedErrorCallback(Device** arg0, ErrorType arg1, StringView arg2, void* arg3, void* arg4); +} + diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PipelineLayoutDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PipelineLayoutDescriptor.gen.cs index 85f4174e5f..10e337aab0 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PipelineLayoutDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PipelineLayoutDescriptor.gen.cs @@ -22,9 +22,10 @@ public unsafe partial struct PipelineLayoutDescriptor public PipelineLayoutDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, + StringView? label = null, nuint? bindGroupLayoutCount = null, - BindGroupLayout** bindGroupLayouts = null + BindGroupLayout** bindGroupLayouts = null, + uint? immediateSize = null ) : this() { if (nextInChain is not null) @@ -34,7 +35,7 @@ public PipelineLayoutDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (bindGroupLayoutCount is not null) @@ -46,18 +47,23 @@ public PipelineLayoutDescriptor { BindGroupLayouts = bindGroupLayouts; } + + if (immediateSize is not null) + { + ImmediateSize = immediateSize.Value; + } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; [NativeName("Type", "size_t")] [NativeName("Type.Name", "size_t")] @@ -68,5 +74,10 @@ public PipelineLayoutDescriptor [NativeName("Type.Name", "const WGPUBindGroupLayout *")] [NativeName("Name", "bindGroupLayouts")] public BindGroupLayout** BindGroupLayouts; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "immediateSize")] + public uint ImmediateSize; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PopErrorScopeCallbackInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PopErrorScopeCallbackInfo.gen.cs similarity index 71% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PopErrorScopeCallbackInfo.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/PopErrorScopeCallbackInfo.gen.cs index 154b7821c1..4bbb4252da 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/PopErrorScopeCallbackInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PopErrorScopeCallbackInfo.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUPopErrorScopeCallbackInfo")] public unsafe partial struct PopErrorScopeCallbackInfo @@ -24,8 +24,8 @@ public PopErrorScopeCallbackInfo ChainedStruct* nextInChain = null, CallbackMode? mode = null, PfnPopErrorScopeCallback? callback = null, - PfnErrorCallback? oldCallback = null, - void* userdata = null + void* userdata1 = null, + void* userdata2 = null ) : this() { if (nextInChain is not null) @@ -43,20 +43,20 @@ public PopErrorScopeCallbackInfo Callback = callback.Value; } - if (oldCallback is not null) + if (userdata1 is not null) { - OldCallback = oldCallback.Value; + Userdata1 = userdata1; } - if (userdata is not null) + if (userdata2 is not null) { - Userdata = userdata; + Userdata2 = userdata2; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -70,14 +70,14 @@ public PopErrorScopeCallbackInfo [NativeName("Name", "callback")] public PfnPopErrorScopeCallback Callback; - [NativeName("Type", "WGPUErrorCallback")] - [NativeName("Type.Name", "WGPUErrorCallback")] - [NativeName("Name", "oldCallback")] - public PfnErrorCallback OldCallback; + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "userdata1")] + public void* Userdata1; [NativeName("Type", "void *")] [NativeName("Type.Name", "void *")] - [NativeName("Name", "userdata")] - public void* Userdata; + [NativeName("Name", "userdata2")] + public void* Userdata2; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/PrimitiveState.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/PrimitiveState.gen.cs index 9c568544f9..7826228d9b 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/PrimitiveState.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/PrimitiveState.gen.cs @@ -25,7 +25,8 @@ public PrimitiveState PrimitiveTopology? topology = null, IndexFormat? stripIndexFormat = null, FrontFace? frontFace = null, - CullMode? cullMode = null + CullMode? cullMode = null, + Silk.NET.Core.Bool32? unclippedDepth = null ) : this() { if (nextInChain is not null) @@ -52,11 +53,16 @@ public PrimitiveState { CullMode = cullMode.Value; } + + if (unclippedDepth is not null) + { + UnclippedDepth = unclippedDepth.Value; + } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -79,5 +85,10 @@ public PrimitiveState [NativeName("Type.Name", "WGPUCullMode")] [NativeName("Name", "cullMode")] public CullMode CullMode; + + [NativeName("Type", "WGPUBool")] + [NativeName("Type.Name", "WGPUBool")] + [NativeName("Name", "unclippedDepth")] + public Silk.NET.Core.Bool32 UnclippedDepth; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/QuerySetDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/QuerySetDescriptor.gen.cs index 30303e53c0..49dcdabb71 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/QuerySetDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/QuerySetDescriptor.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct QuerySetDescriptor public QuerySetDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, + StringView? label = null, QueryType? type = null, uint? count = null ) : this() @@ -34,7 +34,7 @@ public QuerySetDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (type is not null) @@ -49,15 +49,15 @@ public QuerySetDescriptor } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; [NativeName("Type", "WGPUQueryType")] [NativeName("Type.Name", "WGPUQueryType")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/QueueDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/QueueDescriptor.gen.cs index 2c3c442177..be021b0d9f 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/QueueDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/QueueDescriptor.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct QueueDescriptor public QueueDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null + StringView? label = null ) : this() { if (nextInChain is not null) @@ -32,19 +32,19 @@ public QueueDescriptor if (label is not null) { - Label = label; + Label = label.Value; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/QueueWorkDoneCallbackInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/QueueWorkDoneCallbackInfo.gen.cs similarity index 73% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/QueueWorkDoneCallbackInfo.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/QueueWorkDoneCallbackInfo.gen.cs index fb89b6ae88..bb6070ab44 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/QueueWorkDoneCallbackInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/QueueWorkDoneCallbackInfo.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUQueueWorkDoneCallbackInfo")] public unsafe partial struct QueueWorkDoneCallbackInfo @@ -24,7 +24,8 @@ public QueueWorkDoneCallbackInfo ChainedStruct* nextInChain = null, CallbackMode? mode = null, PfnQueueWorkDoneCallback? callback = null, - void* userdata = null + void* userdata1 = null, + void* userdata2 = null ) : this() { if (nextInChain is not null) @@ -42,15 +43,20 @@ public QueueWorkDoneCallbackInfo Callback = callback.Value; } - if (userdata is not null) + if (userdata1 is not null) { - Userdata = userdata; + Userdata1 = userdata1; + } + + if (userdata2 is not null) + { + Userdata2 = userdata2; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -66,7 +72,12 @@ public QueueWorkDoneCallbackInfo [NativeName("Type", "void *")] [NativeName("Type.Name", "void *")] - [NativeName("Name", "userdata")] - public void* Userdata; + [NativeName("Name", "userdata1")] + public void* Userdata1; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "userdata2")] + public void* Userdata2; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderBundleDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderBundleDescriptor.gen.cs index 191ade66d3..9d734c4937 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderBundleDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderBundleDescriptor.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct RenderBundleDescriptor public RenderBundleDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null + StringView? label = null ) : this() { if (nextInChain is not null) @@ -32,19 +32,19 @@ public RenderBundleDescriptor if (label is not null) { - Label = label; + Label = label.Value; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderBundleEncoderDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderBundleEncoderDescriptor.gen.cs index a747ed4ff3..ef5db65019 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderBundleEncoderDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderBundleEncoderDescriptor.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct RenderBundleEncoderDescriptor public RenderBundleEncoderDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, + StringView? label = null, nuint? colorFormatCount = null, TextureFormat* colorFormats = null, TextureFormat? depthStencilFormat = null, @@ -38,7 +38,7 @@ public RenderBundleEncoderDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (colorFormatCount is not null) @@ -73,15 +73,15 @@ public RenderBundleEncoderDescriptor } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; [NativeName("Type", "size_t")] [NativeName("Type.Name", "size_t")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassColorAttachment.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassColorAttachment.gen.cs index 19abf012bd..62f6589eef 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassColorAttachment.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassColorAttachment.gen.cs @@ -67,8 +67,8 @@ public RenderPassColorAttachment } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassDepthStencilAttachment.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassDepthStencilAttachment.gen.cs index e03d297f36..085b915fd7 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassDepthStencilAttachment.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassDepthStencilAttachment.gen.cs @@ -21,6 +21,7 @@ public unsafe partial struct RenderPassDepthStencilAttachment { public RenderPassDepthStencilAttachment ( + ChainedStruct* nextInChain = null, TextureView* view = null, LoadOp? depthLoadOp = null, StoreOp? depthStoreOp = null, @@ -32,6 +33,11 @@ public RenderPassDepthStencilAttachment Silk.NET.Core.Bool32? stencilReadOnly = null ) : this() { + if (nextInChain is not null) + { + NextInChain = nextInChain; + } + if (view is not null) { View = view; @@ -79,6 +85,11 @@ public RenderPassDepthStencilAttachment } + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] + [NativeName("Name", "nextInChain")] + public ChainedStruct* NextInChain; + [NativeName("Type", "WGPUTextureView")] [NativeName("Type.Name", "WGPUTextureView")] [NativeName("Name", "view")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassDescriptor.gen.cs index e94f92c24f..c1e9933168 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassDescriptor.gen.cs @@ -22,12 +22,12 @@ public unsafe partial struct RenderPassDescriptor public RenderPassDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, + StringView? label = null, nuint? colorAttachmentCount = null, RenderPassColorAttachment* colorAttachments = null, RenderPassDepthStencilAttachment* depthStencilAttachment = null, QuerySet* occlusionQuerySet = null, - RenderPassTimestampWrites* timestampWrites = null + PassTimestampWrites* timestampWrites = null ) : this() { if (nextInChain is not null) @@ -37,7 +37,7 @@ public RenderPassDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (colorAttachmentCount is not null) @@ -67,15 +67,15 @@ public RenderPassDescriptor } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; [NativeName("Type", "size_t")] [NativeName("Type.Name", "size_t")] @@ -97,9 +97,9 @@ public RenderPassDescriptor [NativeName("Name", "occlusionQuerySet")] public QuerySet* OcclusionQuerySet; - [NativeName("Type", "const WGPURenderPassTimestampWrites *")] - [NativeName("Type.Name", "const WGPURenderPassTimestampWrites *")] + [NativeName("Type", "const WGPUPassTimestampWrites *")] + [NativeName("Type.Name", "const WGPUPassTimestampWrites *")] [NativeName("Name", "timestampWrites")] - public RenderPassTimestampWrites* TimestampWrites; + public PassTimestampWrites* TimestampWrites; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassMaxDrawCount.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassMaxDrawCount.gen.cs new file mode 100644 index 0000000000..dca6345c0c --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPassMaxDrawCount.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPURenderPassMaxDrawCount")] + public unsafe partial struct RenderPassMaxDrawCount + { + public RenderPassMaxDrawCount + ( + ChainedStruct? chain = null, + ulong? maxDrawCount = null + ) : this() + { + if (chain is not null) + { + Chain = chain.Value; + } + + if (maxDrawCount is not null) + { + MaxDrawCount = maxDrawCount.Value; + } + } + + + [NativeName("Type", "WGPUChainedStruct")] + [NativeName("Type.Name", "WGPUChainedStruct")] + [NativeName("Name", "chain")] + public ChainedStruct Chain; + + [NativeName("Type", "uint64_t")] + [NativeName("Type.Name", "uint64_t")] + [NativeName("Name", "maxDrawCount")] + public ulong MaxDrawCount; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPipelineDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPipelineDescriptor.gen.cs index 0c2638f583..fbf2a05c93 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPipelineDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/RenderPipelineDescriptor.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct RenderPipelineDescriptor public RenderPipelineDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, + StringView? label = null, PipelineLayout* layout = null, VertexState? vertex = null, PrimitiveState? primitive = null, @@ -38,7 +38,7 @@ public RenderPipelineDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (layout is not null) @@ -73,15 +73,15 @@ public RenderPipelineDescriptor } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; [NativeName("Type", "WGPUPipelineLayout")] [NativeName("Type.Name", "WGPUPipelineLayout")] diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RequestAdapterCallbackInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/RequestAdapterCallbackInfo.gen.cs similarity index 73% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RequestAdapterCallbackInfo.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/RequestAdapterCallbackInfo.gen.cs index ffb9c0ba7d..d5e2c1b1f8 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RequestAdapterCallbackInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/RequestAdapterCallbackInfo.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPURequestAdapterCallbackInfo")] public unsafe partial struct RequestAdapterCallbackInfo @@ -24,7 +24,8 @@ public RequestAdapterCallbackInfo ChainedStruct* nextInChain = null, CallbackMode? mode = null, PfnRequestAdapterCallback? callback = null, - void* userdata = null + void* userdata1 = null, + void* userdata2 = null ) : this() { if (nextInChain is not null) @@ -42,15 +43,20 @@ public RequestAdapterCallbackInfo Callback = callback.Value; } - if (userdata is not null) + if (userdata1 is not null) { - Userdata = userdata; + Userdata1 = userdata1; + } + + if (userdata2 is not null) + { + Userdata2 = userdata2; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -66,7 +72,12 @@ public RequestAdapterCallbackInfo [NativeName("Type", "void *")] [NativeName("Type.Name", "void *")] - [NativeName("Name", "userdata")] - public void* Userdata; + [NativeName("Name", "userdata1")] + public void* Userdata1; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "userdata2")] + public void* Userdata2; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RequestAdapterOptions.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/RequestAdapterOptions.gen.cs index 8ee45e459e..e9cdeb2b6e 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/RequestAdapterOptions.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/RequestAdapterOptions.gen.cs @@ -22,10 +22,11 @@ public unsafe partial struct RequestAdapterOptions public RequestAdapterOptions ( ChainedStruct* nextInChain = null, - Surface* compatibleSurface = null, + FeatureLevel? featureLevel = null, PowerPreference? powerPreference = null, + Silk.NET.Core.Bool32? forceFallbackAdapter = null, BackendType? backendType = null, - Silk.NET.Core.Bool32? forceFallbackAdapter = null + Surface* compatibleSurface = null ) : this() { if (nextInChain is not null) @@ -33,9 +34,9 @@ public RequestAdapterOptions NextInChain = nextInChain; } - if (compatibleSurface is not null) + if (featureLevel is not null) { - CompatibleSurface = compatibleSurface; + FeatureLevel = featureLevel.Value; } if (powerPreference is not null) @@ -43,41 +44,51 @@ public RequestAdapterOptions PowerPreference = powerPreference.Value; } + if (forceFallbackAdapter is not null) + { + ForceFallbackAdapter = forceFallbackAdapter.Value; + } + if (backendType is not null) { BackendType = backendType.Value; } - if (forceFallbackAdapter is not null) + if (compatibleSurface is not null) { - ForceFallbackAdapter = forceFallbackAdapter.Value; + CompatibleSurface = compatibleSurface; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "WGPUSurface")] - [NativeName("Type.Name", "WGPUSurface")] - [NativeName("Name", "compatibleSurface")] - public Surface* CompatibleSurface; + [NativeName("Type", "WGPUFeatureLevel")] + [NativeName("Type.Name", "WGPUFeatureLevel")] + [NativeName("Name", "featureLevel")] + public FeatureLevel FeatureLevel; [NativeName("Type", "WGPUPowerPreference")] [NativeName("Type.Name", "WGPUPowerPreference")] [NativeName("Name", "powerPreference")] public PowerPreference PowerPreference; + [NativeName("Type", "WGPUBool")] + [NativeName("Type.Name", "WGPUBool")] + [NativeName("Name", "forceFallbackAdapter")] + public Silk.NET.Core.Bool32 ForceFallbackAdapter; + [NativeName("Type", "WGPUBackendType")] [NativeName("Type.Name", "WGPUBackendType")] [NativeName("Name", "backendType")] public BackendType BackendType; - [NativeName("Type", "WGPUBool")] - [NativeName("Type.Name", "WGPUBool")] - [NativeName("Name", "forceFallbackAdapter")] - public Silk.NET.Core.Bool32 ForceFallbackAdapter; + [NativeName("Type", "WGPUSurface")] + [NativeName("Type.Name", "WGPUSurface")] + [NativeName("Name", "compatibleSurface")] + public Surface* CompatibleSurface; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/RequestAdapterWebXROptions.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/RequestAdapterWebXROptions.gen.cs new file mode 100644 index 0000000000..0d0076202c --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/RequestAdapterWebXROptions.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPURequestAdapterWebXROptions")] + public unsafe partial struct RequestAdapterWebXROptions + { + public RequestAdapterWebXROptions + ( + ChainedStruct? chain = null, + Silk.NET.Core.Bool32? xrCompatible = null + ) : this() + { + if (chain is not null) + { + Chain = chain.Value; + } + + if (xrCompatible is not null) + { + XrCompatible = xrCompatible.Value; + } + } + + + [NativeName("Type", "WGPUChainedStruct")] + [NativeName("Type.Name", "WGPUChainedStruct")] + [NativeName("Name", "chain")] + public ChainedStruct Chain; + + [NativeName("Type", "WGPUBool")] + [NativeName("Type.Name", "WGPUBool")] + [NativeName("Name", "xrCompatible")] + public Silk.NET.Core.Bool32 XrCompatible; + } +} diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RequestDeviceCallbackInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/RequestDeviceCallbackInfo.gen.cs similarity index 73% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RequestDeviceCallbackInfo.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/RequestDeviceCallbackInfo.gen.cs index 8eff11b240..1f6f399088 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/RequestDeviceCallbackInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/RequestDeviceCallbackInfo.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPURequestDeviceCallbackInfo")] public unsafe partial struct RequestDeviceCallbackInfo @@ -24,7 +24,8 @@ public RequestDeviceCallbackInfo ChainedStruct* nextInChain = null, CallbackMode? mode = null, PfnRequestDeviceCallback? callback = null, - void* userdata = null + void* userdata1 = null, + void* userdata2 = null ) : this() { if (nextInChain is not null) @@ -42,15 +43,20 @@ public RequestDeviceCallbackInfo Callback = callback.Value; } - if (userdata is not null) + if (userdata1 is not null) { - Userdata = userdata; + Userdata1 = userdata1; + } + + if (userdata2 is not null) + { + Userdata2 = userdata2; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -66,7 +72,12 @@ public RequestDeviceCallbackInfo [NativeName("Type", "void *")] [NativeName("Type.Name", "void *")] - [NativeName("Name", "userdata")] - public void* Userdata; + [NativeName("Name", "userdata1")] + public void* Userdata1; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "userdata2")] + public void* Userdata2; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SamplerBindingLayout.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SamplerBindingLayout.gen.cs index 10325929c8..834be3cb96 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SamplerBindingLayout.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SamplerBindingLayout.gen.cs @@ -37,8 +37,8 @@ public SamplerBindingLayout } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SamplerDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SamplerDescriptor.gen.cs index 71825d957d..e7d70ba1c3 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SamplerDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SamplerDescriptor.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct SamplerDescriptor public SamplerDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, + StringView? label = null, AddressMode? addressModeU = null, AddressMode? addressModeV = null, AddressMode? addressModeW = null, @@ -42,7 +42,7 @@ public SamplerDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (addressModeU is not null) @@ -97,15 +97,15 @@ public SamplerDescriptor } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; [NativeName("Type", "WGPUAddressMode")] [NativeName("Type.Name", "WGPUAddressMode")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleCompilationHint.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleCompilationHint.gen.cs deleted file mode 100644 index 144e9b5ce9..0000000000 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleCompilationHint.gen.cs +++ /dev/null @@ -1,61 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using System.Runtime.InteropServices; -using System.Runtime.CompilerServices; -using System.Text; -using Silk.NET.Core; -using Silk.NET.Core.Native; -using Silk.NET.Core.Attributes; -using Silk.NET.Core.Contexts; -using Silk.NET.Core.Loader; - -#pragma warning disable 1591 - -namespace Silk.NET.WebGPU -{ - [NativeName("Name", "WGPUShaderModuleCompilationHint")] - public unsafe partial struct ShaderModuleCompilationHint - { - public ShaderModuleCompilationHint - ( - ChainedStruct* nextInChain = null, - byte* entryPoint = null, - PipelineLayout* layout = null - ) : this() - { - if (nextInChain is not null) - { - NextInChain = nextInChain; - } - - if (entryPoint is not null) - { - EntryPoint = entryPoint; - } - - if (layout is not null) - { - Layout = layout; - } - } - - - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] - [NativeName("Name", "nextInChain")] - public ChainedStruct* NextInChain; - - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] - [NativeName("Name", "entryPoint")] - public byte* EntryPoint; - - [NativeName("Type", "WGPUPipelineLayout")] - [NativeName("Type.Name", "WGPUPipelineLayout")] - [NativeName("Name", "layout")] - public PipelineLayout* Layout; - } -} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleDescriptor.gen.cs index 2d9e21b2eb..aae14971cf 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderModuleDescriptor.gen.cs @@ -22,9 +22,7 @@ public unsafe partial struct ShaderModuleDescriptor public ShaderModuleDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, - nuint? hintCount = null, - ShaderModuleCompilationHint* hints = null + StringView? label = null ) : this() { if (nextInChain is not null) @@ -34,39 +32,19 @@ public ShaderModuleDescriptor if (label is not null) { - Label = label; - } - - if (hintCount is not null) - { - HintCount = hintCount.Value; - } - - if (hints is not null) - { - Hints = hints; + Label = label.Value; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; - - [NativeName("Type", "size_t")] - [NativeName("Type.Name", "size_t")] - [NativeName("Name", "hintCount")] - public nuint HintCount; - - [NativeName("Type", "const WGPUShaderModuleCompilationHint *")] - [NativeName("Type.Name", "const WGPUShaderModuleCompilationHint *")] - [NativeName("Name", "hints")] - public ShaderModuleCompilationHint* Hints; + public StringView Label; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderSourceSPIRV.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderSourceSPIRV.gen.cs new file mode 100644 index 0000000000..3181632b9c --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderSourceSPIRV.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUShaderSourceSPIRV")] + public unsafe partial struct ShaderSourceSPIRV + { + public ShaderSourceSPIRV + ( + ChainedStruct? chain = null, + uint? codeSize = null, + uint* code = null + ) : this() + { + if (chain is not null) + { + Chain = chain.Value; + } + + if (codeSize is not null) + { + CodeSize = codeSize.Value; + } + + if (code is not null) + { + Code = code; + } + } + + + [NativeName("Type", "WGPUChainedStruct")] + [NativeName("Type.Name", "WGPUChainedStruct")] + [NativeName("Name", "chain")] + public ChainedStruct Chain; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "codeSize")] + public uint CodeSize; + + [NativeName("Type", "const uint32_t *")] + [NativeName("Type.Name", "const uint32_t *")] + [NativeName("Name", "code")] + public uint* Code; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderSourceWGSL.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderSourceWGSL.gen.cs new file mode 100644 index 0000000000..fec6b5339d --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/ShaderSourceWGSL.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUShaderSourceWGSL")] + public unsafe partial struct ShaderSourceWGSL + { + public ShaderSourceWGSL + ( + ChainedStruct? chain = null, + StringView? code = null + ) : this() + { + if (chain is not null) + { + Chain = chain.Value; + } + + if (code is not null) + { + Code = code.Value; + } + } + + + [NativeName("Type", "WGPUChainedStruct")] + [NativeName("Type.Name", "WGPUChainedStruct")] + [NativeName("Name", "chain")] + public ChainedStruct Chain; + + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] + [NativeName("Name", "code")] + public StringView Code; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/StorageTextureBindingLayout.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/StorageTextureBindingLayout.gen.cs index 2bfe564170..f6ea004b80 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/StorageTextureBindingLayout.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/StorageTextureBindingLayout.gen.cs @@ -49,8 +49,8 @@ public StorageTextureBindingLayout } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/StringView.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/StringView.gen.cs new file mode 100644 index 0000000000..209e4da52a --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/StringView.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUStringView")] + public unsafe partial struct StringView + { + public StringView + ( + byte* data = null, + nuint? length = null + ) : this() + { + if (data is not null) + { + Data = data; + } + + if (length is not null) + { + Length = length.Value; + } + } + + + [NativeName("Type", "const char *")] + [NativeName("Type.Name", "const char *")] + [NativeName("Name", "data")] + public byte* Data; + + [NativeName("Type", "size_t")] + [NativeName("Type.Name", "size_t")] + [NativeName("Name", "length")] + public nuint Length; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SupportedFeatures.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SupportedFeatures.gen.cs new file mode 100644 index 0000000000..4be9b7a50c --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SupportedFeatures.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUSupportedFeatures")] + public unsafe partial struct SupportedFeatures + { + public SupportedFeatures + ( + nuint? featureCount = null, + FeatureName* features = null + ) : this() + { + if (featureCount is not null) + { + FeatureCount = featureCount.Value; + } + + if (features is not null) + { + Features = features; + } + } + + + [NativeName("Type", "size_t")] + [NativeName("Type.Name", "size_t")] + [NativeName("Name", "featureCount")] + public nuint FeatureCount; + + [NativeName("Type", "const WGPUFeatureName *")] + [NativeName("Type.Name", "const WGPUFeatureName *")] + [NativeName("Name", "features")] + public FeatureName* Features; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SupportedInstanceFeatures.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SupportedInstanceFeatures.gen.cs new file mode 100644 index 0000000000..eedcf700d7 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SupportedInstanceFeatures.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUSupportedInstanceFeatures")] + public unsafe partial struct SupportedInstanceFeatures + { + public SupportedInstanceFeatures + ( + nuint? featureCount = null, + InstanceFeatureName* features = null + ) : this() + { + if (featureCount is not null) + { + FeatureCount = featureCount.Value; + } + + if (features is not null) + { + Features = features; + } + } + + + [NativeName("Type", "size_t")] + [NativeName("Type.Name", "size_t")] + [NativeName("Name", "featureCount")] + public nuint FeatureCount; + + [NativeName("Type", "const WGPUInstanceFeatureName *")] + [NativeName("Type.Name", "const WGPUInstanceFeatureName *")] + [NativeName("Name", "features")] + public InstanceFeatureName* Features; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SupportedWGSLLanguageFeatures.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SupportedWGSLLanguageFeatures.gen.cs new file mode 100644 index 0000000000..c37c8974c2 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SupportedWGSLLanguageFeatures.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUSupportedWGSLLanguageFeatures")] + public unsafe partial struct SupportedWGSLLanguageFeatures + { + public SupportedWGSLLanguageFeatures + ( + nuint? featureCount = null, + WGSLLanguageFeatureName* features = null + ) : this() + { + if (featureCount is not null) + { + FeatureCount = featureCount.Value; + } + + if (features is not null) + { + Features = features; + } + } + + + [NativeName("Type", "size_t")] + [NativeName("Type.Name", "size_t")] + [NativeName("Name", "featureCount")] + public nuint FeatureCount; + + [NativeName("Type", "const WGPUWGSLLanguageFeatureName *")] + [NativeName("Type.Name", "const WGPUWGSLLanguageFeatureName *")] + [NativeName("Name", "features")] + public WGSLLanguageFeatureName* Features; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceCapabilities.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceCapabilities.gen.cs index a3895e2a7e..e545f820f7 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceCapabilities.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceCapabilities.gen.cs @@ -21,7 +21,8 @@ public unsafe partial struct SurfaceCapabilities { public SurfaceCapabilities ( - ChainedStructOut* nextInChain = null, + ChainedStruct* nextInChain = null, + ulong? usages = null, nuint? formatCount = null, TextureFormat* formats = null, nuint? presentModeCount = null, @@ -35,6 +36,11 @@ public SurfaceCapabilities NextInChain = nextInChain; } + if (usages is not null) + { + Usages = usages.Value; + } + if (formatCount is not null) { FormatCount = formatCount.Value; @@ -67,10 +73,15 @@ public SurfaceCapabilities } - [NativeName("Type", "WGPUChainedStructOut *")] - [NativeName("Type.Name", "WGPUChainedStructOut *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] - public ChainedStructOut* NextInChain; + public ChainedStruct* NextInChain; + + [NativeName("Type", "WGPUTextureUsage")] + [NativeName("Type.Name", "WGPUTextureUsage")] + [NativeName("Name", "usages")] + public ulong Usages; [NativeName("Type", "size_t")] [NativeName("Type.Name", "size_t")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceColorManagement.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceColorManagement.gen.cs new file mode 100644 index 0000000000..2218f8ad7d --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceColorManagement.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUSurfaceColorManagement")] + public unsafe partial struct SurfaceColorManagement + { + public SurfaceColorManagement + ( + ChainedStruct? chain = null, + PredefinedColorSpace? colorSpace = null, + ToneMappingMode? toneMappingMode = null + ) : this() + { + if (chain is not null) + { + Chain = chain.Value; + } + + if (colorSpace is not null) + { + ColorSpace = colorSpace.Value; + } + + if (toneMappingMode is not null) + { + ToneMappingMode = toneMappingMode.Value; + } + } + + + [NativeName("Type", "WGPUChainedStruct")] + [NativeName("Type.Name", "WGPUChainedStruct")] + [NativeName("Name", "chain")] + public ChainedStruct Chain; + + [NativeName("Type", "WGPUPredefinedColorSpace")] + [NativeName("Type.Name", "WGPUPredefinedColorSpace")] + [NativeName("Name", "colorSpace")] + public PredefinedColorSpace ColorSpace; + + [NativeName("Type", "WGPUToneMappingMode")] + [NativeName("Type.Name", "WGPUToneMappingMode")] + [NativeName("Name", "toneMappingMode")] + public ToneMappingMode ToneMappingMode; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceConfiguration.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceConfiguration.gen.cs index 4f48bb5ea7..2e9700ce33 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceConfiguration.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceConfiguration.gen.cs @@ -24,12 +24,12 @@ public SurfaceConfiguration ChainedStruct* nextInChain = null, Device* device = null, TextureFormat? format = null, - Silk.NET.WebGPU.TextureUsage? usage = null, + ulong? usage = null, + uint? width = null, + uint? height = null, nuint? viewFormatCount = null, TextureFormat* viewFormats = null, CompositeAlphaMode? alphaMode = null, - uint? width = null, - uint? height = null, PresentMode? presentMode = null ) : this() { @@ -53,29 +53,29 @@ public SurfaceConfiguration Usage = usage.Value; } - if (viewFormatCount is not null) + if (width is not null) { - ViewFormatCount = viewFormatCount.Value; + Width = width.Value; } - if (viewFormats is not null) + if (height is not null) { - ViewFormats = viewFormats; + Height = height.Value; } - if (alphaMode is not null) + if (viewFormatCount is not null) { - AlphaMode = alphaMode.Value; + ViewFormatCount = viewFormatCount.Value; } - if (width is not null) + if (viewFormats is not null) { - Width = width.Value; + ViewFormats = viewFormats; } - if (height is not null) + if (alphaMode is not null) { - Height = height.Value; + AlphaMode = alphaMode.Value; } if (presentMode is not null) @@ -85,8 +85,8 @@ public SurfaceConfiguration } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -100,10 +100,20 @@ public SurfaceConfiguration [NativeName("Name", "format")] public TextureFormat Format; - [NativeName("Type", "WGPUTextureUsageFlags")] - [NativeName("Type.Name", "WGPUTextureUsageFlags")] + [NativeName("Type", "WGPUTextureUsage")] + [NativeName("Type.Name", "WGPUTextureUsage")] [NativeName("Name", "usage")] - public Silk.NET.WebGPU.TextureUsage Usage; + public ulong Usage; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "width")] + public uint Width; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "height")] + public uint Height; [NativeName("Type", "size_t")] [NativeName("Type.Name", "size_t")] @@ -120,16 +130,6 @@ public SurfaceConfiguration [NativeName("Name", "alphaMode")] public CompositeAlphaMode AlphaMode; - [NativeName("Type", "uint32_t")] - [NativeName("Type.Name", "uint32_t")] - [NativeName("Name", "width")] - public uint Width; - - [NativeName("Type", "uint32_t")] - [NativeName("Type.Name", "uint32_t")] - [NativeName("Name", "height")] - public uint Height; - [NativeName("Type", "WGPUPresentMode")] [NativeName("Type.Name", "WGPUPresentMode")] [NativeName("Name", "presentMode")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptor.gen.cs index 29e0bd719f..12ec3a7c33 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptor.gen.cs @@ -22,7 +22,7 @@ public unsafe partial struct SurfaceDescriptor public SurfaceDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null + StringView? label = null ) : this() { if (nextInChain is not null) @@ -32,19 +32,19 @@ public SurfaceDescriptor if (label is not null) { - Label = label; + Label = label.Value; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceAndroidNativeWindow.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceAndroidNativeWindow.gen.cs new file mode 100644 index 0000000000..433f39b262 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceAndroidNativeWindow.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUSurfaceSourceAndroidNativeWindow")] + public unsafe partial struct SurfaceSourceAndroidNativeWindow + { + public SurfaceSourceAndroidNativeWindow + ( + ChainedStruct? chain = null, + void* window = null + ) : this() + { + if (chain is not null) + { + Chain = chain.Value; + } + + if (window is not null) + { + Window = window; + } + } + + + [NativeName("Type", "WGPUChainedStruct")] + [NativeName("Type.Name", "WGPUChainedStruct")] + [NativeName("Name", "chain")] + public ChainedStruct Chain; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "window")] + public void* Window; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceMetalLayer.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceMetalLayer.gen.cs new file mode 100644 index 0000000000..ad0837c705 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceMetalLayer.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUSurfaceSourceMetalLayer")] + public unsafe partial struct SurfaceSourceMetalLayer + { + public SurfaceSourceMetalLayer + ( + ChainedStruct? chain = null, + void* layer = null + ) : this() + { + if (chain is not null) + { + Chain = chain.Value; + } + + if (layer is not null) + { + Layer = layer; + } + } + + + [NativeName("Type", "WGPUChainedStruct")] + [NativeName("Type.Name", "WGPUChainedStruct")] + [NativeName("Name", "chain")] + public ChainedStruct Chain; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "layer")] + public void* Layer; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceWaylandSurface.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceWaylandSurface.gen.cs new file mode 100644 index 0000000000..14c6fec902 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceWaylandSurface.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUSurfaceSourceWaylandSurface")] + public unsafe partial struct SurfaceSourceWaylandSurface + { + public SurfaceSourceWaylandSurface + ( + ChainedStruct? chain = null, + void* display = null, + void* surface = null + ) : this() + { + if (chain is not null) + { + Chain = chain.Value; + } + + if (display is not null) + { + Display = display; + } + + if (surface is not null) + { + Surface = surface; + } + } + + + [NativeName("Type", "WGPUChainedStruct")] + [NativeName("Type.Name", "WGPUChainedStruct")] + [NativeName("Name", "chain")] + public ChainedStruct Chain; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "display")] + public void* Display; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "surface")] + public void* Surface; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceWindowsHWND.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceWindowsHWND.gen.cs new file mode 100644 index 0000000000..4847f2f1c6 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceWindowsHWND.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUSurfaceSourceWindowsHWND")] + public unsafe partial struct SurfaceSourceWindowsHWND + { + public SurfaceSourceWindowsHWND + ( + ChainedStruct? chain = null, + void* hinstance = null, + void* hwnd = null + ) : this() + { + if (chain is not null) + { + Chain = chain.Value; + } + + if (hinstance is not null) + { + Hinstance = hinstance; + } + + if (hwnd is not null) + { + Hwnd = hwnd; + } + } + + + [NativeName("Type", "WGPUChainedStruct")] + [NativeName("Type.Name", "WGPUChainedStruct")] + [NativeName("Name", "chain")] + public ChainedStruct Chain; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "hinstance")] + public void* Hinstance; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "hwnd")] + public void* Hwnd; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromXcbWindow.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceXCBWindow.gen.cs similarity index 89% rename from src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromXcbWindow.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceXCBWindow.gen.cs index 45b7976bbf..2cdb67ade7 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceDescriptorFromXcbWindow.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceXCBWindow.gen.cs @@ -16,10 +16,10 @@ namespace Silk.NET.WebGPU { - [NativeName("Name", "WGPUSurfaceDescriptorFromXcbWindow")] - public unsafe partial struct SurfaceDescriptorFromXcbWindow + [NativeName("Name", "WGPUSurfaceSourceXCBWindow")] + public unsafe partial struct SurfaceSourceXCBWindow { - public SurfaceDescriptorFromXcbWindow + public SurfaceSourceXCBWindow ( ChainedStruct? chain = null, void* connection = null, diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceXlibWindow.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceXlibWindow.gen.cs new file mode 100644 index 0000000000..a4195bf823 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceSourceXlibWindow.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUSurfaceSourceXlibWindow")] + public unsafe partial struct SurfaceSourceXlibWindow + { + public SurfaceSourceXlibWindow + ( + ChainedStruct? chain = null, + void* display = null, + ulong? window = null + ) : this() + { + if (chain is not null) + { + Chain = chain.Value; + } + + if (display is not null) + { + Display = display; + } + + if (window is not null) + { + Window = window.Value; + } + } + + + [NativeName("Type", "WGPUChainedStruct")] + [NativeName("Type.Name", "WGPUChainedStruct")] + [NativeName("Name", "chain")] + public ChainedStruct Chain; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "display")] + public void* Display; + + [NativeName("Type", "uint64_t")] + [NativeName("Type.Name", "uint64_t")] + [NativeName("Name", "window")] + public ulong Window; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceTexture.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceTexture.gen.cs index c24851df26..65a7ec42d3 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceTexture.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/SurfaceTexture.gen.cs @@ -21,19 +21,19 @@ public unsafe partial struct SurfaceTexture { public SurfaceTexture ( + ChainedStruct* nextInChain = null, Texture* texture = null, - Silk.NET.Core.Bool32? suboptimal = null, SurfaceGetCurrentTextureStatus? status = null ) : this() { - if (texture is not null) + if (nextInChain is not null) { - Texture = texture; + NextInChain = nextInChain; } - if (suboptimal is not null) + if (texture is not null) { - Suboptimal = suboptimal.Value; + Texture = texture; } if (status is not null) @@ -43,16 +43,16 @@ public SurfaceTexture } + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] + [NativeName("Name", "nextInChain")] + public ChainedStruct* NextInChain; + [NativeName("Type", "WGPUTexture")] [NativeName("Type.Name", "WGPUTexture")] [NativeName("Name", "texture")] public Texture* Texture; - [NativeName("Type", "WGPUBool")] - [NativeName("Type.Name", "WGPUBool")] - [NativeName("Name", "suboptimal")] - public Silk.NET.Core.Bool32 Suboptimal; - [NativeName("Type", "WGPUSurfaceGetCurrentTextureStatus")] [NativeName("Type.Name", "WGPUSurfaceGetCurrentTextureStatus")] [NativeName("Name", "status")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyBufferInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyBufferInfo.gen.cs new file mode 100644 index 0000000000..2e97553d50 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyBufferInfo.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUTexelCopyBufferInfo")] + public unsafe partial struct TexelCopyBufferInfo + { + public TexelCopyBufferInfo + ( + TexelCopyBufferLayout? layout = null, + Buffer* buffer = null + ) : this() + { + if (layout is not null) + { + Layout = layout.Value; + } + + if (buffer is not null) + { + Buffer = buffer; + } + } + + + [NativeName("Type", "WGPUTexelCopyBufferLayout")] + [NativeName("Type.Name", "WGPUTexelCopyBufferLayout")] + [NativeName("Name", "layout")] + public TexelCopyBufferLayout Layout; + + [NativeName("Type", "WGPUBuffer")] + [NativeName("Type.Name", "WGPUBuffer")] + [NativeName("Name", "buffer")] + public Buffer* Buffer; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyBufferLayout.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyBufferLayout.gen.cs new file mode 100644 index 0000000000..6d64a055b2 --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyBufferLayout.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUTexelCopyBufferLayout")] + public unsafe partial struct TexelCopyBufferLayout + { + public TexelCopyBufferLayout + ( + ulong? offset = null, + uint? bytesPerRow = null, + uint? rowsPerImage = null + ) : this() + { + if (offset is not null) + { + Offset = offset.Value; + } + + if (bytesPerRow is not null) + { + BytesPerRow = bytesPerRow.Value; + } + + if (rowsPerImage is not null) + { + RowsPerImage = rowsPerImage.Value; + } + } + + + [NativeName("Type", "uint64_t")] + [NativeName("Type.Name", "uint64_t")] + [NativeName("Name", "offset")] + public ulong Offset; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "bytesPerRow")] + public uint BytesPerRow; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "rowsPerImage")] + public uint RowsPerImage; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyTextureInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyTextureInfo.gen.cs new file mode 100644 index 0000000000..f122cb49ec --- /dev/null +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/TexelCopyTextureInfo.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WebGPU +{ + [NativeName("Name", "WGPUTexelCopyTextureInfo")] + public unsafe partial struct TexelCopyTextureInfo + { + public TexelCopyTextureInfo + ( + Texture* texture = null, + uint? mipLevel = null, + Origin3D? origin = null, + TextureAspect? aspect = null + ) : this() + { + if (texture is not null) + { + Texture = texture; + } + + if (mipLevel is not null) + { + MipLevel = mipLevel.Value; + } + + if (origin is not null) + { + Origin = origin.Value; + } + + if (aspect is not null) + { + Aspect = aspect.Value; + } + } + + + [NativeName("Type", "WGPUTexture")] + [NativeName("Type.Name", "WGPUTexture")] + [NativeName("Name", "texture")] + public Texture* Texture; + + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "mipLevel")] + public uint MipLevel; + + [NativeName("Type", "WGPUOrigin3D")] + [NativeName("Type.Name", "WGPUOrigin3D")] + [NativeName("Name", "origin")] + public Origin3D Origin; + + [NativeName("Type", "WGPUTextureAspect")] + [NativeName("Type.Name", "WGPUTextureAspect")] + [NativeName("Name", "aspect")] + public TextureAspect Aspect; + } +} diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/TextureBindingLayout.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/TextureBindingLayout.gen.cs index 6ebd24f0e5..b6320a8d67 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/TextureBindingLayout.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/TextureBindingLayout.gen.cs @@ -49,8 +49,8 @@ public TextureBindingLayout } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/TextureDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/TextureDescriptor.gen.cs index da47c68624..75daaf89ae 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/TextureDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/TextureDescriptor.gen.cs @@ -22,8 +22,8 @@ public unsafe partial struct TextureDescriptor public TextureDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, - Silk.NET.WebGPU.TextureUsage? usage = null, + StringView? label = null, + ulong? usage = null, TextureDimension? dimension = null, Extent3D? size = null, TextureFormat? format = null, @@ -40,7 +40,7 @@ public TextureDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (usage is not null) @@ -85,20 +85,20 @@ public TextureDescriptor } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; - [NativeName("Type", "WGPUTextureUsageFlags")] - [NativeName("Type.Name", "WGPUTextureUsageFlags")] + [NativeName("Type", "WGPUTextureUsage")] + [NativeName("Type.Name", "WGPUTextureUsage")] [NativeName("Name", "usage")] - public Silk.NET.WebGPU.TextureUsage Usage; + public ulong Usage; [NativeName("Type", "WGPUTextureDimension")] [NativeName("Type.Name", "WGPUTextureDimension")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/TextureViewDescriptor.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/TextureViewDescriptor.gen.cs index 5b6fb84d50..feb13552f0 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/TextureViewDescriptor.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/TextureViewDescriptor.gen.cs @@ -22,14 +22,15 @@ public unsafe partial struct TextureViewDescriptor public TextureViewDescriptor ( ChainedStruct* nextInChain = null, - byte* label = null, + StringView? label = null, TextureFormat? format = null, TextureViewDimension? dimension = null, uint? baseMipLevel = null, uint? mipLevelCount = null, uint? baseArrayLayer = null, uint? arrayLayerCount = null, - TextureAspect? aspect = null + TextureAspect? aspect = null, + ulong? usage = null ) : this() { if (nextInChain is not null) @@ -39,7 +40,7 @@ public TextureViewDescriptor if (label is not null) { - Label = label; + Label = label.Value; } if (format is not null) @@ -76,18 +77,23 @@ public TextureViewDescriptor { Aspect = aspect.Value; } + + if (usage is not null) + { + Usage = usage.Value; + } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "label")] - public byte* Label; + public StringView Label; [NativeName("Type", "WGPUTextureFormat")] [NativeName("Type.Name", "WGPUTextureFormat")] @@ -123,5 +129,10 @@ public TextureViewDescriptor [NativeName("Type.Name", "WGPUTextureAspect")] [NativeName("Name", "aspect")] public TextureAspect Aspect; + + [NativeName("Type", "WGPUTextureUsage")] + [NativeName("Type.Name", "WGPUTextureUsage")] + [NativeName("Name", "usage")] + public ulong Usage; } } diff --git a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/UncapturedErrorCallbackInfo.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/UncapturedErrorCallbackInfo.gen.cs similarity index 57% rename from src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/UncapturedErrorCallbackInfo.gen.cs rename to src/WebGPU/Silk.NET.WebGPU/Structs/UncapturedErrorCallbackInfo.gen.cs index fc7e23761a..094e343e9b 100644 --- a/src/WebGPU/Extensions/Silk.NET.WebGPU.Extensions.Dawn/Structs/UncapturedErrorCallbackInfo.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/UncapturedErrorCallbackInfo.gen.cs @@ -14,7 +14,7 @@ #pragma warning disable 1591 -namespace Silk.NET.WebGPU.Extensions.Dawn +namespace Silk.NET.WebGPU { [NativeName("Name", "WGPUUncapturedErrorCallbackInfo")] public unsafe partial struct UncapturedErrorCallbackInfo @@ -22,8 +22,9 @@ public unsafe partial struct UncapturedErrorCallbackInfo public UncapturedErrorCallbackInfo ( ChainedStruct* nextInChain = null, - PfnErrorCallback? callback = null, - void* userdata = null + PfnUncapturedErrorCallback? callback = null, + void* userdata1 = null, + void* userdata2 = null ) : this() { if (nextInChain is not null) @@ -36,26 +37,36 @@ public UncapturedErrorCallbackInfo Callback = callback.Value; } - if (userdata is not null) + if (userdata1 is not null) { - Userdata = userdata; + Userdata1 = userdata1; + } + + if (userdata2 is not null) + { + Userdata2 = userdata2; } } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; - [NativeName("Type", "WGPUErrorCallback")] - [NativeName("Type.Name", "WGPUErrorCallback")] + [NativeName("Type", "WGPUUncapturedErrorCallback")] + [NativeName("Type.Name", "WGPUUncapturedErrorCallback")] [NativeName("Name", "callback")] - public PfnErrorCallback Callback; + public PfnUncapturedErrorCallback Callback; + + [NativeName("Type", "void *")] + [NativeName("Type.Name", "void *")] + [NativeName("Name", "userdata1")] + public void* Userdata1; [NativeName("Type", "void *")] [NativeName("Type.Name", "void *")] - [NativeName("Name", "userdata")] - public void* Userdata; + [NativeName("Name", "userdata2")] + public void* Userdata2; } } diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/VertexAttribute.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/VertexAttribute.gen.cs index c8f5b4113b..84c9a4d16b 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/VertexAttribute.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/VertexAttribute.gen.cs @@ -21,11 +21,17 @@ public unsafe partial struct VertexAttribute { public VertexAttribute ( + ChainedStruct* nextInChain = null, VertexFormat? format = null, ulong? offset = null, uint? shaderLocation = null ) : this() { + if (nextInChain is not null) + { + NextInChain = nextInChain; + } + if (format is not null) { Format = format.Value; @@ -43,6 +49,11 @@ public VertexAttribute } + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] + [NativeName("Name", "nextInChain")] + public ChainedStruct* NextInChain; + [NativeName("Type", "WGPUVertexFormat")] [NativeName("Type.Name", "WGPUVertexFormat")] [NativeName("Name", "format")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/VertexBufferLayout.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/VertexBufferLayout.gen.cs index 26d54c2c8d..a197488521 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/VertexBufferLayout.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/VertexBufferLayout.gen.cs @@ -21,15 +21,16 @@ public unsafe partial struct VertexBufferLayout { public VertexBufferLayout ( - ulong? arrayStride = null, + ChainedStruct* nextInChain = null, VertexStepMode? stepMode = null, + ulong? arrayStride = null, nuint? attributeCount = null, VertexAttribute* attributes = null ) : this() { - if (arrayStride is not null) + if (nextInChain is not null) { - ArrayStride = arrayStride.Value; + NextInChain = nextInChain; } if (stepMode is not null) @@ -37,6 +38,11 @@ public VertexBufferLayout StepMode = stepMode.Value; } + if (arrayStride is not null) + { + ArrayStride = arrayStride.Value; + } + if (attributeCount is not null) { AttributeCount = attributeCount.Value; @@ -49,16 +55,21 @@ public VertexBufferLayout } - [NativeName("Type", "uint64_t")] - [NativeName("Type.Name", "uint64_t")] - [NativeName("Name", "arrayStride")] - public ulong ArrayStride; + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] + [NativeName("Name", "nextInChain")] + public ChainedStruct* NextInChain; [NativeName("Type", "WGPUVertexStepMode")] [NativeName("Type.Name", "WGPUVertexStepMode")] [NativeName("Name", "stepMode")] public VertexStepMode StepMode; + [NativeName("Type", "uint64_t")] + [NativeName("Type.Name", "uint64_t")] + [NativeName("Name", "arrayStride")] + public ulong ArrayStride; + [NativeName("Type", "size_t")] [NativeName("Type.Name", "size_t")] [NativeName("Name", "attributeCount")] diff --git a/src/WebGPU/Silk.NET.WebGPU/Structs/VertexState.gen.cs b/src/WebGPU/Silk.NET.WebGPU/Structs/VertexState.gen.cs index 445c2c59e0..978198a5d7 100644 --- a/src/WebGPU/Silk.NET.WebGPU/Structs/VertexState.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/Structs/VertexState.gen.cs @@ -23,7 +23,7 @@ public VertexState ( ChainedStruct* nextInChain = null, ShaderModule* module = null, - byte* entryPoint = null, + StringView? entryPoint = null, nuint? constantCount = null, ConstantEntry* constants = null, nuint? bufferCount = null, @@ -42,7 +42,7 @@ public VertexState if (entryPoint is not null) { - EntryPoint = entryPoint; + EntryPoint = entryPoint.Value; } if (constantCount is not null) @@ -67,8 +67,8 @@ public VertexState } - [NativeName("Type", "const WGPUChainedStruct *")] - [NativeName("Type.Name", "const WGPUChainedStruct *")] + [NativeName("Type", "WGPUChainedStruct *")] + [NativeName("Type.Name", "WGPUChainedStruct *")] [NativeName("Name", "nextInChain")] public ChainedStruct* NextInChain; @@ -77,10 +77,10 @@ public VertexState [NativeName("Name", "module")] public ShaderModule* Module; - [NativeName("Type", "const char *")] - [NativeName("Type.Name", "const char *")] + [NativeName("Type", "WGPUStringView")] + [NativeName("Type.Name", "WGPUStringView")] [NativeName("Name", "entryPoint")] - public byte* EntryPoint; + public StringView EntryPoint; [NativeName("Type", "size_t")] [NativeName("Type.Name", "size_t")] diff --git a/src/WebGPU/Silk.NET.WebGPU/WebGPU.gen.cs b/src/WebGPU/Silk.NET.WebGPU/WebGPU.gen.cs index 6baa3c5a23..6836b694f0 100644 --- a/src/WebGPU/Silk.NET.WebGPU/WebGPU.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/WebGPU.gen.cs @@ -16,28 +16,127 @@ namespace Silk.NET.WebGPU { public unsafe partial class WebGPU : NativeAPI { - [NativeName("Type", "unsigned long")] + [NativeName("Type", "const WGPUBufferUsage")] + [NativeName("Name", "WGPUBufferUsage_None")] + public const ulong BufferUsageNone = unchecked((ulong) 0x0); + [NativeName("Type", "const WGPUBufferUsage")] + [NativeName("Name", "WGPUBufferUsage_MapRead")] + public const ulong BufferUsageMapRead = unchecked((ulong) 0x1); + [NativeName("Type", "const WGPUBufferUsage")] + [NativeName("Name", "WGPUBufferUsage_MapWrite")] + public const ulong BufferUsageMapWrite = unchecked((ulong) 0x2); + [NativeName("Type", "const WGPUBufferUsage")] + [NativeName("Name", "WGPUBufferUsage_CopySrc")] + public const ulong BufferUsageCopySrc = unchecked((ulong) 0x4); + [NativeName("Type", "const WGPUBufferUsage")] + [NativeName("Name", "WGPUBufferUsage_CopyDst")] + public const ulong BufferUsageCopyDst = unchecked((ulong) 0x8); + [NativeName("Type", "const WGPUBufferUsage")] + [NativeName("Name", "WGPUBufferUsage_Index")] + public const ulong BufferUsageIndex = unchecked((ulong) 0x10); + [NativeName("Type", "const WGPUBufferUsage")] + [NativeName("Name", "WGPUBufferUsage_Vertex")] + public const ulong BufferUsageVertex = unchecked((ulong) 0x20); + [NativeName("Type", "const WGPUBufferUsage")] + [NativeName("Name", "WGPUBufferUsage_Uniform")] + public const ulong BufferUsageUniform = unchecked((ulong) 0x40); + [NativeName("Type", "const WGPUBufferUsage")] + [NativeName("Name", "WGPUBufferUsage_Storage")] + public const ulong BufferUsageStorage = unchecked((ulong) 0x80); + [NativeName("Type", "const WGPUBufferUsage")] + [NativeName("Name", "WGPUBufferUsage_Indirect")] + public const ulong BufferUsageIndirect = unchecked((ulong) 0x100); + [NativeName("Type", "const WGPUBufferUsage")] + [NativeName("Name", "WGPUBufferUsage_QueryResolve")] + public const ulong BufferUsageQueryResolve = unchecked((ulong) 0x200); + [NativeName("Type", "const WGPUColorWriteMask")] + [NativeName("Name", "WGPUColorWriteMask_None")] + public const ulong ColorWriteMaskNone = unchecked((ulong) 0x0); + [NativeName("Type", "const WGPUColorWriteMask")] + [NativeName("Name", "WGPUColorWriteMask_Red")] + public const ulong ColorWriteMaskRed = unchecked((ulong) 0x1); + [NativeName("Type", "const WGPUColorWriteMask")] + [NativeName("Name", "WGPUColorWriteMask_Green")] + public const ulong ColorWriteMaskGreen = unchecked((ulong) 0x2); + [NativeName("Type", "const WGPUColorWriteMask")] + [NativeName("Name", "WGPUColorWriteMask_Blue")] + public const ulong ColorWriteMaskBlue = unchecked((ulong) 0x4); + [NativeName("Type", "const WGPUColorWriteMask")] + [NativeName("Name", "WGPUColorWriteMask_Alpha")] + public const ulong ColorWriteMaskAlpha = unchecked((ulong) 0x8); + [NativeName("Type", "const WGPUColorWriteMask")] + [NativeName("Name", "WGPUColorWriteMask_All")] + public const ulong ColorWriteMaskAll = unchecked((ulong) 0xF); + [NativeName("Type", "const WGPUMapMode")] + [NativeName("Name", "WGPUMapMode_None")] + public const ulong MapModeNone = unchecked((ulong) 0x0); + [NativeName("Type", "const WGPUMapMode")] + [NativeName("Name", "WGPUMapMode_Read")] + public const ulong MapModeRead = unchecked((ulong) 0x1); + [NativeName("Type", "const WGPUMapMode")] + [NativeName("Name", "WGPUMapMode_Write")] + public const ulong MapModeWrite = unchecked((ulong) 0x2); + [NativeName("Type", "const WGPUShaderStage")] + [NativeName("Name", "WGPUShaderStage_None")] + public const ulong ShaderStageNone = unchecked((ulong) 0x0); + [NativeName("Type", "const WGPUShaderStage")] + [NativeName("Name", "WGPUShaderStage_Vertex")] + public const ulong ShaderStageVertex = unchecked((ulong) 0x1); + [NativeName("Type", "const WGPUShaderStage")] + [NativeName("Name", "WGPUShaderStage_Fragment")] + public const ulong ShaderStageFragment = unchecked((ulong) 0x2); + [NativeName("Type", "const WGPUShaderStage")] + [NativeName("Name", "WGPUShaderStage_Compute")] + public const ulong ShaderStageCompute = unchecked((ulong) 0x4); + [NativeName("Type", "const WGPUTextureUsage")] + [NativeName("Name", "WGPUTextureUsage_None")] + public const ulong TextureUsageNone = unchecked((ulong) 0x0); + [NativeName("Type", "const WGPUTextureUsage")] + [NativeName("Name", "WGPUTextureUsage_CopySrc")] + public const ulong TextureUsageCopySrc = unchecked((ulong) 0x1); + [NativeName("Type", "const WGPUTextureUsage")] + [NativeName("Name", "WGPUTextureUsage_CopyDst")] + public const ulong TextureUsageCopyDst = unchecked((ulong) 0x2); + [NativeName("Type", "const WGPUTextureUsage")] + [NativeName("Name", "WGPUTextureUsage_TextureBinding")] + public const ulong TextureUsageTextureBinding = unchecked((ulong) 0x4); + [NativeName("Type", "const WGPUTextureUsage")] + [NativeName("Name", "WGPUTextureUsage_StorageBinding")] + public const ulong TextureUsageStorageBinding = unchecked((ulong) 0x8); + [NativeName("Type", "const WGPUTextureUsage")] + [NativeName("Name", "WGPUTextureUsage_RenderAttachment")] + public const ulong TextureUsageRenderAttachment = unchecked((ulong) 0x10); + [NativeName("Type", "unsigned int")] + [NativeName("Name", "WGPU_TRUE")] + public const uint True = unchecked((uint) 0x1); + [NativeName("Type", "unsigned int")] + [NativeName("Name", "WGPU_FALSE")] + public const uint False = unchecked((uint) 0x0); + [NativeName("Type", "unsigned int")] [NativeName("Name", "WGPU_ARRAY_LAYER_COUNT_UNDEFINED")] public const uint ArrayLayerCountUndefined = unchecked((uint) 0xFFFFFFFFFFFFFFFF); - [NativeName("Type", "unsigned long")] + [NativeName("Type", "unsigned int")] [NativeName("Name", "WGPU_COPY_STRIDE_UNDEFINED")] public const uint CopyStrideUndefined = unchecked((uint) 0xFFFFFFFFFFFFFFFF); - [NativeName("Type", "unsigned long")] + [NativeName("Type", "unsigned int")] [NativeName("Name", "WGPU_DEPTH_SLICE_UNDEFINED")] public const uint DepthSliceUndefined = unchecked((uint) 0xFFFFFFFFFFFFFFFF); - [NativeName("Type", "unsigned long")] + [NativeName("Type", "unsigned int")] [NativeName("Name", "WGPU_LIMIT_U32_UNDEFINED")] public const uint LimitU32Undefined = unchecked((uint) 0xFFFFFFFFFFFFFFFF); [NativeName("Type", "unsigned long long")] [NativeName("Name", "WGPU_LIMIT_U64_UNDEFINED")] public const ulong LimitU64Undefined = unchecked((ulong) 0xFFFFFFFFFFFFFFFF); - [NativeName("Type", "unsigned long")] + [NativeName("Type", "unsigned int")] [NativeName("Name", "WGPU_MIP_LEVEL_COUNT_UNDEFINED")] public const uint MipLevelCountUndefined = unchecked((uint) 0xFFFFFFFFFFFFFFFF); - [NativeName("Type", "unsigned long")] + [NativeName("Type", "unsigned int")] [NativeName("Name", "WGPU_QUERY_SET_INDEX_UNDEFINED")] public const uint QuerySetIndexUndefined = unchecked((uint) 0xFFFFFFFFFFFFFFFF); [NativeName("Type", "unsigned long long")] + [NativeName("Name", "WGPU_STRLEN")] + public const ulong Strlen = unchecked((ulong) 0xFFFFFFFFFFFFFFFF); + [NativeName("Type", "unsigned long long")] [NativeName("Name", "WGPU_WHOLE_MAP_SIZE")] public const ulong WholeMapSize = unchecked((ulong) 0xFFFFFFFFFFFFFFFF); [NativeName("Type", "unsigned long long")] @@ -45,1657 +144,1382 @@ public unsafe partial class WebGPU : NativeAPI public const ulong WholeSize = unchecked((ulong) 0xFFFFFFFFFFFFFFFF); /// To be documented. - [NativeName("Src", "Line 1562, Column 26 in webgpu.h")] + [NativeName("Src", "Line 5673, Column 26 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCreateInstance")] public unsafe partial Instance* CreateInstance([Flow(Silk.NET.Core.Native.FlowDirection.In)] InstanceDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1562, Column 26 in webgpu.h")] + [NativeName("Src", "Line 5673, Column 26 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCreateInstance")] public unsafe partial Instance* CreateInstance([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly InstanceDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1563, Column 22 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuGetProcAddress")] - public unsafe partial PfnProc GetProcAddress(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* procName); - - /// To be documented. - [NativeName("Src", "Line 1563, Column 22 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuGetProcAddress")] - public unsafe partial PfnProc GetProcAddress(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte procName); + [NativeName("Src", "Line 5680, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuGetInstanceFeatures")] + public unsafe partial void GetInstanceFeatures(SupportedInstanceFeatures* features); /// To be documented. - [NativeName("Src", "Line 1563, Column 22 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuGetProcAddress")] - public unsafe partial PfnProc GetProcAddress(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string procName); + [NativeName("Src", "Line 5680, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuGetInstanceFeatures")] + public partial void GetInstanceFeatures(ref SupportedInstanceFeatures features); /// To be documented. - [NativeName("Src", "Line 1566, Column 20 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterEnumerateFeatures")] - public unsafe partial nuint AdapterEnumerateFeatures(Adapter* adapter, FeatureName* features); + [NativeName("Src", "Line 5687, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuGetInstanceLimits")] + public unsafe partial Status GetInstanceLimits(InstanceLimits* limits); /// To be documented. - [NativeName("Src", "Line 1566, Column 20 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterEnumerateFeatures")] - public unsafe partial nuint AdapterEnumerateFeatures(Adapter* adapter, ref FeatureName features); + [NativeName("Src", "Line 5687, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuGetInstanceLimits")] + public partial Status GetInstanceLimits(ref InstanceLimits limits); /// To be documented. - [NativeName("Src", "Line 1567, Column 22 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterGetLimits")] - public unsafe partial Silk.NET.Core.Bool32 AdapterGetLimits(Adapter* adapter, SupportedLimits* limits); + [NativeName("Src", "Line 5691, Column 22 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuHasInstanceFeature")] + public partial Silk.NET.Core.Bool32 HasInstanceFeature(InstanceFeatureName feature); /// To be documented. - [NativeName("Src", "Line 1567, Column 22 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterGetLimits")] - public unsafe partial Silk.NET.Core.Bool32 AdapterGetLimits(Adapter* adapter, ref SupportedLimits limits); + [NativeName("Src", "Line 5696, Column 22 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuGetProcAddress")] + public partial PfnProc GetProcAddress(StringView procName); /// To be documented. - [NativeName("Src", "Line 1568, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterGetProperties")] - public unsafe partial void AdapterGetProperties(Adapter* adapter, AdapterProperties* properties); + [NativeName("Src", "Line 5719, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterGetFeatures")] + public unsafe partial void AdapterGetFeatures(Adapter* adapter, SupportedFeatures* features); /// To be documented. - [NativeName("Src", "Line 1568, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterGetProperties")] - public unsafe partial void AdapterGetProperties(Adapter* adapter, ref AdapterProperties properties); + [NativeName("Src", "Line 5719, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterGetFeatures")] + public unsafe partial void AdapterGetFeatures(Adapter* adapter, ref SupportedFeatures features); /// To be documented. - [NativeName("Src", "Line 1569, Column 22 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterHasFeature")] - public unsafe partial Silk.NET.Core.Bool32 AdapterHasFeature(Adapter* adapter, FeatureName feature); + [NativeName("Src", "Line 5727, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterGetInfo")] + public unsafe partial Status AdapterGetInfo(Adapter* adapter, AdapterInfo* info); /// To be documented. - [NativeName("Src", "Line 1570, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterRequestAdapterInfo")] - public unsafe partial void AdapterRequestAdapterInfo(Adapter* adapter, PfnAdapterRequestAdapterInfoCallback callback, void* userdata); + [NativeName("Src", "Line 5727, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterGetInfo")] + public unsafe partial Status AdapterGetInfo(Adapter* adapter, ref AdapterInfo info); /// To be documented. - [NativeName("Src", "Line 1570, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterRequestAdapterInfo")] - public unsafe partial void AdapterRequestAdapterInfo(Adapter* adapter, PfnAdapterRequestAdapterInfoCallback callback, ref T0 userdata) where T0 : unmanaged; + [NativeName("Src", "Line 5732, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterGetLimits")] + public unsafe partial Status AdapterGetLimits(Adapter* adapter, Limits* limits); /// To be documented. - [NativeName("Src", "Line 1571, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterRequestDevice")] - public unsafe partial void AdapterRequestDevice(Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DeviceDescriptor* descriptor, PfnRequestDeviceCallback callback, void* userdata); + [NativeName("Src", "Line 5732, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterGetLimits")] + public unsafe partial Status AdapterGetLimits(Adapter* adapter, ref Limits limits); /// To be documented. - [NativeName("Src", "Line 1571, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterRequestDevice")] - public unsafe partial void AdapterRequestDevice(Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DeviceDescriptor* descriptor, PfnRequestDeviceCallback callback, ref T0 userdata) where T0 : unmanaged; + [NativeName("Src", "Line 5733, Column 22 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterHasFeature")] + public unsafe partial Silk.NET.Core.Bool32 AdapterHasFeature(Adapter* adapter, FeatureName feature); /// To be documented. - [NativeName("Src", "Line 1571, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5734, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuAdapterRequestDevice")] - public unsafe partial void AdapterRequestDevice(Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DeviceDescriptor descriptor, PfnRequestDeviceCallback callback, void* userdata); + public unsafe partial Future AdapterRequestDevice(Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DeviceDescriptor* descriptor, RequestDeviceCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1571, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5734, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuAdapterRequestDevice")] - public unsafe partial void AdapterRequestDevice(Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DeviceDescriptor descriptor, PfnRequestDeviceCallback callback, ref T0 userdata) where T0 : unmanaged; + public unsafe partial Future AdapterRequestDevice(Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DeviceDescriptor descriptor, RequestDeviceCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1572, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuAdapterReference")] - public unsafe partial void AdapterReference(Adapter* adapter); + [NativeName("Src", "Line 5735, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterAddRef")] + public unsafe partial void AdapterAddRef(Adapter* adapter); /// To be documented. - [NativeName("Src", "Line 1573, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5736, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuAdapterRelease")] public unsafe partial void AdapterRelease(Adapter* adapter); /// To be documented. - [NativeName("Src", "Line 1576, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBindGroupSetLabel")] - public unsafe partial void BindGroupSetLabel(BindGroup* bindGroup, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + [NativeName("Src", "Line 5749, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuAdapterInfoFreeMembers")] + public partial void AdapterInfoFreeMembers(AdapterInfo adapterInfo); /// To be documented. - [NativeName("Src", "Line 1576, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5759, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBindGroupSetLabel")] - public unsafe partial void BindGroupSetLabel(BindGroup* bindGroup, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + public unsafe partial void BindGroupSetLabel(BindGroup* bindGroup, StringView label); /// To be documented. - [NativeName("Src", "Line 1576, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBindGroupSetLabel")] - public unsafe partial void BindGroupSetLabel(BindGroup* bindGroup, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + [NativeName("Src", "Line 5760, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuBindGroupAddRef")] + public unsafe partial void BindGroupAddRef(BindGroup* bindGroup); /// To be documented. - [NativeName("Src", "Line 1577, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBindGroupReference")] - public unsafe partial void BindGroupReference(BindGroup* bindGroup); - - /// To be documented. - [NativeName("Src", "Line 1578, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5761, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBindGroupRelease")] public unsafe partial void BindGroupRelease(BindGroup* bindGroup); /// To be documented. - [NativeName("Src", "Line 1581, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBindGroupLayoutSetLabel")] - public unsafe partial void BindGroupLayoutSetLabel(BindGroupLayout* bindGroupLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); - - /// To be documented. - [NativeName("Src", "Line 1581, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5771, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBindGroupLayoutSetLabel")] - public unsafe partial void BindGroupLayoutSetLabel(BindGroupLayout* bindGroupLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + public unsafe partial void BindGroupLayoutSetLabel(BindGroupLayout* bindGroupLayout, StringView label); /// To be documented. - [NativeName("Src", "Line 1581, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBindGroupLayoutSetLabel")] - public unsafe partial void BindGroupLayoutSetLabel(BindGroupLayout* bindGroupLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + [NativeName("Src", "Line 5772, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuBindGroupLayoutAddRef")] + public unsafe partial void BindGroupLayoutAddRef(BindGroupLayout* bindGroupLayout); /// To be documented. - [NativeName("Src", "Line 1582, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBindGroupLayoutReference")] - public unsafe partial void BindGroupLayoutReference(BindGroupLayout* bindGroupLayout); - - /// To be documented. - [NativeName("Src", "Line 1583, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5773, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBindGroupLayoutRelease")] public unsafe partial void BindGroupLayoutRelease(BindGroupLayout* bindGroupLayout); /// To be documented. - [NativeName("Src", "Line 1586, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5783, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBufferDestroy")] public unsafe partial void BufferDestroy(Buffer* buffer); /// To be documented. - [NativeName("Src", "Line 1587, Column 26 in webgpu.h")] + [NativeName("Src", "Line 5801, Column 26 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBufferGetConstMappedRange")] public unsafe partial void* BufferGetConstMappedRange(Buffer* buffer, nuint offset, nuint size); /// To be documented. - [NativeName("Src", "Line 1588, Column 32 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBufferGetMapState")] - public unsafe partial BufferMapState BufferGetMapState(Buffer* buffer); - - /// To be documented. - [NativeName("Src", "Line 1589, Column 20 in webgpu.h")] + [NativeName("Src", "Line 5818, Column 20 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBufferGetMappedRange")] public unsafe partial void* BufferGetMappedRange(Buffer* buffer, nuint offset, nuint size); /// To be documented. - [NativeName("Src", "Line 1590, Column 22 in webgpu.h")] + [NativeName("Src", "Line 5819, Column 32 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuBufferGetMapState")] + public unsafe partial BufferMapState BufferGetMapState(Buffer* buffer); + + /// To be documented. + [NativeName("Src", "Line 5820, Column 22 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBufferGetSize")] public unsafe partial ulong BufferGetSize(Buffer* buffer); /// To be documented. - [NativeName("Src", "Line 1591, Column 34 in webgpu.h")] + [NativeName("Src", "Line 5821, Column 29 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBufferGetUsage")] - public unsafe partial Silk.NET.WebGPU.BufferUsage BufferGetUsage(Buffer* buffer); + public unsafe partial ulong BufferGetUsage(Buffer* buffer); /// To be documented. - [NativeName("Src", "Line 1592, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5830, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBufferMapAsync")] - public unsafe partial void BufferMapAsync(Buffer* buffer, Silk.NET.WebGPU.MapMode mode, nuint offset, nuint size, PfnBufferMapCallback callback, void* userdata); + public unsafe partial Future BufferMapAsync(Buffer* buffer, ulong mode, nuint offset, nuint size, BufferMapCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1592, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBufferMapAsync")] - public unsafe partial void BufferMapAsync(Buffer* buffer, Silk.NET.WebGPU.MapMode mode, nuint offset, nuint size, PfnBufferMapCallback callback, ref T0 userdata) where T0 : unmanaged; + [NativeName("Src", "Line 5851, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuBufferReadMappedRange")] + public unsafe partial Status BufferReadMappedRange(Buffer* buffer, nuint offset, void* data, nuint size); /// To be documented. - [NativeName("Src", "Line 1593, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBufferSetLabel")] - public unsafe partial void BufferSetLabel(Buffer* buffer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + [NativeName("Src", "Line 5851, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuBufferReadMappedRange")] + public unsafe partial Status BufferReadMappedRange(Buffer* buffer, nuint offset, ref T0 data, nuint size) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1593, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5852, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBufferSetLabel")] - public unsafe partial void BufferSetLabel(Buffer* buffer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + public unsafe partial void BufferSetLabel(Buffer* buffer, StringView label); /// To be documented. - [NativeName("Src", "Line 1593, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBufferSetLabel")] - public unsafe partial void BufferSetLabel(Buffer* buffer, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); - - /// To be documented. - [NativeName("Src", "Line 1594, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5853, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuBufferUnmap")] public unsafe partial void BufferUnmap(Buffer* buffer); /// To be documented. - [NativeName("Src", "Line 1595, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBufferReference")] - public unsafe partial void BufferReference(Buffer* buffer); + [NativeName("Src", "Line 5874, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuBufferWriteMappedRange")] + public unsafe partial Status BufferWriteMappedRange(Buffer* buffer, nuint offset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint size); /// To be documented. - [NativeName("Src", "Line 1596, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuBufferRelease")] - public unsafe partial void BufferRelease(Buffer* buffer); + [NativeName("Src", "Line 5874, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuBufferWriteMappedRange")] + public unsafe partial Status BufferWriteMappedRange(Buffer* buffer, nuint offset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint size) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1599, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandBufferSetLabel")] - public unsafe partial void CommandBufferSetLabel(CommandBuffer* commandBuffer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + [NativeName("Src", "Line 5875, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuBufferAddRef")] + public unsafe partial void BufferAddRef(Buffer* buffer); /// To be documented. - [NativeName("Src", "Line 1599, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandBufferSetLabel")] - public unsafe partial void CommandBufferSetLabel(CommandBuffer* commandBuffer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + [NativeName("Src", "Line 5876, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuBufferRelease")] + public unsafe partial void BufferRelease(Buffer* buffer); /// To be documented. - [NativeName("Src", "Line 1599, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5886, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandBufferSetLabel")] - public unsafe partial void CommandBufferSetLabel(CommandBuffer* commandBuffer, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + public unsafe partial void CommandBufferSetLabel(CommandBuffer* commandBuffer, StringView label); /// To be documented. - [NativeName("Src", "Line 1600, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandBufferReference")] - public unsafe partial void CommandBufferReference(CommandBuffer* commandBuffer); + [NativeName("Src", "Line 5887, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandBufferAddRef")] + public unsafe partial void CommandBufferAddRef(CommandBuffer* commandBuffer); /// To be documented. - [NativeName("Src", "Line 1601, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5888, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandBufferRelease")] public unsafe partial void CommandBufferRelease(CommandBuffer* commandBuffer); /// To be documented. - [NativeName("Src", "Line 1604, Column 36 in webgpu.h")] + [NativeName("Src", "Line 5902, Column 36 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderBeginComputePass")] public unsafe partial ComputePassEncoder* CommandEncoderBeginComputePass(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ComputePassDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1604, Column 36 in webgpu.h")] + [NativeName("Src", "Line 5902, Column 36 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderBeginComputePass")] public unsafe partial ComputePassEncoder* CommandEncoderBeginComputePass(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ComputePassDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1605, Column 35 in webgpu.h")] + [NativeName("Src", "Line 5907, Column 35 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderBeginRenderPass")] public unsafe partial RenderPassEncoder* CommandEncoderBeginRenderPass(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RenderPassDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1605, Column 35 in webgpu.h")] + [NativeName("Src", "Line 5907, Column 35 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderBeginRenderPass")] public unsafe partial RenderPassEncoder* CommandEncoderBeginRenderPass(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly RenderPassDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1606, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5908, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderClearBuffer")] public unsafe partial void CommandEncoderClearBuffer(CommandEncoder* commandEncoder, Buffer* buffer, ulong offset, ulong size); /// To be documented. - [NativeName("Src", "Line 1607, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5909, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToBuffer")] public unsafe partial void CommandEncoderCopyBufferToBuffer(CommandEncoder* commandEncoder, Buffer* source, ulong sourceOffset, Buffer* destination, ulong destinationOffset, ulong size); /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] - public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] - public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] - public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] - public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] - public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] - public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] - public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyBufferToTexture")] - public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyBufferToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] - public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] - public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] - public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] - public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] - public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] - public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] - public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToBuffer")] - public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyBuffer destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyTextureToBuffer(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] - public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] - public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] - public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] - public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] - public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] - public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] - public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize); /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderCopyTextureToTexture")] - public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); + public unsafe partial void CommandEncoderCopyTextureToTexture(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D copySize); /// To be documented. - [NativeName("Src", "Line 1611, Column 31 in webgpu.h")] + [NativeName("Src", "Line 5917, Column 31 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderFinish")] public unsafe partial CommandBuffer* CommandEncoderFinish(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CommandBufferDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1611, Column 31 in webgpu.h")] + [NativeName("Src", "Line 5917, Column 31 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderFinish")] public unsafe partial CommandBuffer* CommandEncoderFinish(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly CommandBufferDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1612, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandEncoderInsertDebugMarker")] - public unsafe partial void CommandEncoderInsertDebugMarker(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* markerLabel); - - /// To be documented. - [NativeName("Src", "Line 1612, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandEncoderInsertDebugMarker")] - public unsafe partial void CommandEncoderInsertDebugMarker(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte markerLabel); - - /// To be documented. - [NativeName("Src", "Line 1612, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5918, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderInsertDebugMarker")] - public unsafe partial void CommandEncoderInsertDebugMarker(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string markerLabel); + public unsafe partial void CommandEncoderInsertDebugMarker(CommandEncoder* commandEncoder, StringView markerLabel); /// To be documented. - [NativeName("Src", "Line 1613, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5919, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderPopDebugGroup")] public unsafe partial void CommandEncoderPopDebugGroup(CommandEncoder* commandEncoder); /// To be documented. - [NativeName("Src", "Line 1614, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandEncoderPushDebugGroup")] - public unsafe partial void CommandEncoderPushDebugGroup(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* groupLabel); - - /// To be documented. - [NativeName("Src", "Line 1614, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandEncoderPushDebugGroup")] - public unsafe partial void CommandEncoderPushDebugGroup(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte groupLabel); - - /// To be documented. - [NativeName("Src", "Line 1614, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5920, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderPushDebugGroup")] - public unsafe partial void CommandEncoderPushDebugGroup(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string groupLabel); + public unsafe partial void CommandEncoderPushDebugGroup(CommandEncoder* commandEncoder, StringView groupLabel); /// To be documented. - [NativeName("Src", "Line 1615, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5921, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderResolveQuerySet")] public unsafe partial void CommandEncoderResolveQuerySet(CommandEncoder* commandEncoder, QuerySet* querySet, uint firstQuery, uint queryCount, Buffer* destination, ulong destinationOffset); /// To be documented. - [NativeName("Src", "Line 1616, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5922, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderSetLabel")] - public unsafe partial void CommandEncoderSetLabel(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + public unsafe partial void CommandEncoderSetLabel(CommandEncoder* commandEncoder, StringView label); /// To be documented. - [NativeName("Src", "Line 1616, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandEncoderSetLabel")] - public unsafe partial void CommandEncoderSetLabel(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); - - /// To be documented. - [NativeName("Src", "Line 1616, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandEncoderSetLabel")] - public unsafe partial void CommandEncoderSetLabel(CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); - - /// To be documented. - [NativeName("Src", "Line 1617, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5923, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderWriteTimestamp")] public unsafe partial void CommandEncoderWriteTimestamp(CommandEncoder* commandEncoder, QuerySet* querySet, uint queryIndex); /// To be documented. - [NativeName("Src", "Line 1618, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuCommandEncoderReference")] - public unsafe partial void CommandEncoderReference(CommandEncoder* commandEncoder); + [NativeName("Src", "Line 5924, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuCommandEncoderAddRef")] + public unsafe partial void CommandEncoderAddRef(CommandEncoder* commandEncoder); /// To be documented. - [NativeName("Src", "Line 1619, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5925, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuCommandEncoderRelease")] public unsafe partial void CommandEncoderRelease(CommandEncoder* commandEncoder); /// To be documented. - [NativeName("Src", "Line 1622, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5935, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderDispatchWorkgroups")] public unsafe partial void ComputePassEncoderDispatchWorkgroups(ComputePassEncoder* computePassEncoder, uint workgroupCountX, uint workgroupCountY, uint workgroupCountZ); /// To be documented. - [NativeName("Src", "Line 1623, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5936, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderDispatchWorkgroupsIndirect")] public unsafe partial void ComputePassEncoderDispatchWorkgroupsIndirect(ComputePassEncoder* computePassEncoder, Buffer* indirectBuffer, ulong indirectOffset); /// To be documented. - [NativeName("Src", "Line 1624, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5937, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderEnd")] public unsafe partial void ComputePassEncoderEnd(ComputePassEncoder* computePassEncoder); /// To be documented. - [NativeName("Src", "Line 1625, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5938, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderInsertDebugMarker")] - public unsafe partial void ComputePassEncoderInsertDebugMarker(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* markerLabel); + public unsafe partial void ComputePassEncoderInsertDebugMarker(ComputePassEncoder* computePassEncoder, StringView markerLabel); /// To be documented. - [NativeName("Src", "Line 1625, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePassEncoderInsertDebugMarker")] - public unsafe partial void ComputePassEncoderInsertDebugMarker(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte markerLabel); - - /// To be documented. - [NativeName("Src", "Line 1625, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePassEncoderInsertDebugMarker")] - public unsafe partial void ComputePassEncoderInsertDebugMarker(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string markerLabel); - - /// To be documented. - [NativeName("Src", "Line 1626, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5939, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderPopDebugGroup")] public unsafe partial void ComputePassEncoderPopDebugGroup(ComputePassEncoder* computePassEncoder); /// To be documented. - [NativeName("Src", "Line 1627, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePassEncoderPushDebugGroup")] - public unsafe partial void ComputePassEncoderPushDebugGroup(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* groupLabel); - - /// To be documented. - [NativeName("Src", "Line 1627, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5940, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderPushDebugGroup")] - public unsafe partial void ComputePassEncoderPushDebugGroup(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte groupLabel); + public unsafe partial void ComputePassEncoderPushDebugGroup(ComputePassEncoder* computePassEncoder, StringView groupLabel); /// To be documented. - [NativeName("Src", "Line 1627, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePassEncoderPushDebugGroup")] - public unsafe partial void ComputePassEncoderPushDebugGroup(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string groupLabel); - - /// To be documented. - [NativeName("Src", "Line 1628, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5941, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderSetBindGroup")] public unsafe partial void ComputePassEncoderSetBindGroup(ComputePassEncoder* computePassEncoder, uint groupIndex, BindGroup* group, nuint dynamicOffsetCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint* dynamicOffsets); /// To be documented. - [NativeName("Src", "Line 1628, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5941, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderSetBindGroup")] public unsafe partial void ComputePassEncoderSetBindGroup(ComputePassEncoder* computePassEncoder, uint groupIndex, BindGroup* group, nuint dynamicOffsetCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly uint dynamicOffsets); /// To be documented. - [NativeName("Src", "Line 1629, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePassEncoderSetLabel")] - public unsafe partial void ComputePassEncoderSetLabel(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); - - /// To be documented. - [NativeName("Src", "Line 1629, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePassEncoderSetLabel")] - public unsafe partial void ComputePassEncoderSetLabel(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); - - /// To be documented. - [NativeName("Src", "Line 1629, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5942, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderSetLabel")] - public unsafe partial void ComputePassEncoderSetLabel(ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + public unsafe partial void ComputePassEncoderSetLabel(ComputePassEncoder* computePassEncoder, StringView label); /// To be documented. - [NativeName("Src", "Line 1630, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5943, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderSetPipeline")] public unsafe partial void ComputePassEncoderSetPipeline(ComputePassEncoder* computePassEncoder, ComputePipeline* pipeline); /// To be documented. - [NativeName("Src", "Line 1631, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePassEncoderReference")] - public unsafe partial void ComputePassEncoderReference(ComputePassEncoder* computePassEncoder); + [NativeName("Src", "Line 5944, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePassEncoderAddRef")] + public unsafe partial void ComputePassEncoderAddRef(ComputePassEncoder* computePassEncoder); /// To be documented. - [NativeName("Src", "Line 1632, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5945, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePassEncoderRelease")] public unsafe partial void ComputePassEncoderRelease(ComputePassEncoder* computePassEncoder); /// To be documented. - [NativeName("Src", "Line 1635, Column 33 in webgpu.h")] + [NativeName("Src", "Line 5959, Column 33 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePipelineGetBindGroupLayout")] public unsafe partial BindGroupLayout* ComputePipelineGetBindGroupLayout(ComputePipeline* computePipeline, uint groupIndex); /// To be documented. - [NativeName("Src", "Line 1636, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5960, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePipelineSetLabel")] - public unsafe partial void ComputePipelineSetLabel(ComputePipeline* computePipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + public unsafe partial void ComputePipelineSetLabel(ComputePipeline* computePipeline, StringView label); /// To be documented. - [NativeName("Src", "Line 1636, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePipelineSetLabel")] - public unsafe partial void ComputePipelineSetLabel(ComputePipeline* computePipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + [NativeName("Src", "Line 5961, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuComputePipelineAddRef")] + public unsafe partial void ComputePipelineAddRef(ComputePipeline* computePipeline); /// To be documented. - [NativeName("Src", "Line 1636, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePipelineSetLabel")] - public unsafe partial void ComputePipelineSetLabel(ComputePipeline* computePipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); - - /// To be documented. - [NativeName("Src", "Line 1637, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuComputePipelineReference")] - public unsafe partial void ComputePipelineReference(ComputePipeline* computePipeline); - - /// To be documented. - [NativeName("Src", "Line 1638, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5962, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuComputePipelineRelease")] public unsafe partial void ComputePipelineRelease(ComputePipeline* computePipeline); /// To be documented. - [NativeName("Src", "Line 1641, Column 27 in webgpu.h")] + [NativeName("Src", "Line 5976, Column 27 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateBindGroup")] public unsafe partial BindGroup* DeviceCreateBindGroup(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BindGroupDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1641, Column 27 in webgpu.h")] + [NativeName("Src", "Line 5976, Column 27 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateBindGroup")] public unsafe partial BindGroup* DeviceCreateBindGroup(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly BindGroupDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1642, Column 33 in webgpu.h")] + [NativeName("Src", "Line 5981, Column 33 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateBindGroupLayout")] public unsafe partial BindGroupLayout* DeviceCreateBindGroupLayout(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BindGroupLayoutDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1642, Column 33 in webgpu.h")] + [NativeName("Src", "Line 5981, Column 33 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateBindGroupLayout")] public unsafe partial BindGroupLayout* DeviceCreateBindGroupLayout(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly BindGroupLayoutDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1643, Column 24 in webgpu.h")] + [NativeName("Src", "Line 5991, Column 38 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateBuffer")] public unsafe partial Buffer* DeviceCreateBuffer(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BufferDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1643, Column 24 in webgpu.h")] + [NativeName("Src", "Line 5991, Column 38 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateBuffer")] public unsafe partial Buffer* DeviceCreateBuffer(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly BufferDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1644, Column 32 in webgpu.h")] + [NativeName("Src", "Line 5996, Column 32 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateCommandEncoder")] public unsafe partial CommandEncoder* DeviceCreateCommandEncoder(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] CommandEncoderDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1644, Column 32 in webgpu.h")] + [NativeName("Src", "Line 5996, Column 32 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateCommandEncoder")] public unsafe partial CommandEncoder* DeviceCreateCommandEncoder(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly CommandEncoderDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1645, Column 33 in webgpu.h")] + [NativeName("Src", "Line 6001, Column 33 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateComputePipeline")] public unsafe partial ComputePipeline* DeviceCreateComputePipeline(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ComputePipelineDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1645, Column 33 in webgpu.h")] + [NativeName("Src", "Line 6001, Column 33 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateComputePipeline")] public unsafe partial ComputePipeline* DeviceCreateComputePipeline(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ComputePipelineDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1646, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceCreateComputePipelineAsync")] - public unsafe partial void DeviceCreateComputePipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ComputePipelineDescriptor* descriptor, PfnCreateComputePipelineAsyncCallback callback, void* userdata); - - /// To be documented. - [NativeName("Src", "Line 1646, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceCreateComputePipelineAsync")] - public unsafe partial void DeviceCreateComputePipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ComputePipelineDescriptor* descriptor, PfnCreateComputePipelineAsyncCallback callback, ref T0 userdata) where T0 : unmanaged; - - /// To be documented. - [NativeName("Src", "Line 1646, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6002, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateComputePipelineAsync")] - public unsafe partial void DeviceCreateComputePipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ComputePipelineDescriptor descriptor, PfnCreateComputePipelineAsyncCallback callback, void* userdata); + public unsafe partial Future DeviceCreateComputePipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ComputePipelineDescriptor* descriptor, CreateComputePipelineAsyncCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1646, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6002, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateComputePipelineAsync")] - public unsafe partial void DeviceCreateComputePipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ComputePipelineDescriptor descriptor, PfnCreateComputePipelineAsyncCallback callback, ref T0 userdata) where T0 : unmanaged; + public unsafe partial Future DeviceCreateComputePipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ComputePipelineDescriptor descriptor, CreateComputePipelineAsyncCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1647, Column 32 in webgpu.h")] + [NativeName("Src", "Line 6007, Column 32 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreatePipelineLayout")] public unsafe partial PipelineLayout* DeviceCreatePipelineLayout(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PipelineLayoutDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1647, Column 32 in webgpu.h")] + [NativeName("Src", "Line 6007, Column 32 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreatePipelineLayout")] public unsafe partial PipelineLayout* DeviceCreatePipelineLayout(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PipelineLayoutDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1648, Column 26 in webgpu.h")] + [NativeName("Src", "Line 6012, Column 26 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateQuerySet")] public unsafe partial QuerySet* DeviceCreateQuerySet(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] QuerySetDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1648, Column 26 in webgpu.h")] + [NativeName("Src", "Line 6012, Column 26 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateQuerySet")] public unsafe partial QuerySet* DeviceCreateQuerySet(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly QuerySetDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1649, Column 37 in webgpu.h")] + [NativeName("Src", "Line 6017, Column 37 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateRenderBundleEncoder")] public unsafe partial RenderBundleEncoder* DeviceCreateRenderBundleEncoder(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RenderBundleEncoderDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1649, Column 37 in webgpu.h")] + [NativeName("Src", "Line 6017, Column 37 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateRenderBundleEncoder")] public unsafe partial RenderBundleEncoder* DeviceCreateRenderBundleEncoder(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly RenderBundleEncoderDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1650, Column 32 in webgpu.h")] + [NativeName("Src", "Line 6022, Column 32 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateRenderPipeline")] public unsafe partial RenderPipeline* DeviceCreateRenderPipeline(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RenderPipelineDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1650, Column 32 in webgpu.h")] + [NativeName("Src", "Line 6022, Column 32 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateRenderPipeline")] public unsafe partial RenderPipeline* DeviceCreateRenderPipeline(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly RenderPipelineDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1651, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6023, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateRenderPipelineAsync")] - public unsafe partial void DeviceCreateRenderPipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RenderPipelineDescriptor* descriptor, PfnCreateRenderPipelineAsyncCallback callback, void* userdata); + public unsafe partial Future DeviceCreateRenderPipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RenderPipelineDescriptor* descriptor, CreateRenderPipelineAsyncCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1651, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6023, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateRenderPipelineAsync")] - public unsafe partial void DeviceCreateRenderPipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RenderPipelineDescriptor* descriptor, PfnCreateRenderPipelineAsyncCallback callback, ref T0 userdata) where T0 : unmanaged; + public unsafe partial Future DeviceCreateRenderPipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly RenderPipelineDescriptor descriptor, CreateRenderPipelineAsyncCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1651, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceCreateRenderPipelineAsync")] - public unsafe partial void DeviceCreateRenderPipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly RenderPipelineDescriptor descriptor, PfnCreateRenderPipelineAsyncCallback callback, void* userdata); - - /// To be documented. - [NativeName("Src", "Line 1651, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceCreateRenderPipelineAsync")] - public unsafe partial void DeviceCreateRenderPipelineAsync(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly RenderPipelineDescriptor descriptor, PfnCreateRenderPipelineAsyncCallback callback, ref T0 userdata) where T0 : unmanaged; - - /// To be documented. - [NativeName("Src", "Line 1652, Column 25 in webgpu.h")] + [NativeName("Src", "Line 6028, Column 25 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateSampler")] public unsafe partial Sampler* DeviceCreateSampler(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1652, Column 25 in webgpu.h")] + [NativeName("Src", "Line 6028, Column 25 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateSampler")] public unsafe partial Sampler* DeviceCreateSampler(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly SamplerDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1653, Column 30 in webgpu.h")] + [NativeName("Src", "Line 6033, Column 30 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateShaderModule")] public unsafe partial ShaderModule* DeviceCreateShaderModule(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ShaderModuleDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1653, Column 30 in webgpu.h")] + [NativeName("Src", "Line 6033, Column 30 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateShaderModule")] public unsafe partial ShaderModule* DeviceCreateShaderModule(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ShaderModuleDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1654, Column 25 in webgpu.h")] + [NativeName("Src", "Line 6038, Column 25 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateTexture")] public unsafe partial Texture* DeviceCreateTexture(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1654, Column 25 in webgpu.h")] + [NativeName("Src", "Line 6038, Column 25 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceCreateTexture")] public unsafe partial Texture* DeviceCreateTexture(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1655, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6039, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceDestroy")] public unsafe partial void DeviceDestroy(Device* device); /// To be documented. - [NativeName("Src", "Line 1656, Column 20 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceEnumerateFeatures")] - public unsafe partial nuint DeviceEnumerateFeatures(Device* device, FeatureName* features); + [NativeName("Src", "Line 6047, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceGetAdapterInfo")] + public unsafe partial Status DeviceGetAdapterInfo(Device* device, AdapterInfo* adapterInfo); + + /// To be documented. + [NativeName("Src", "Line 6047, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceGetAdapterInfo")] + public unsafe partial Status DeviceGetAdapterInfo(Device* device, ref AdapterInfo adapterInfo); + + /// To be documented. + [NativeName("Src", "Line 6054, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceGetFeatures")] + public unsafe partial void DeviceGetFeatures(Device* device, SupportedFeatures* features); /// To be documented. - [NativeName("Src", "Line 1656, Column 20 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceEnumerateFeatures")] - public unsafe partial nuint DeviceEnumerateFeatures(Device* device, ref FeatureName features); + [NativeName("Src", "Line 6054, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceGetFeatures")] + public unsafe partial void DeviceGetFeatures(Device* device, ref SupportedFeatures features); /// To be documented. - [NativeName("Src", "Line 1657, Column 22 in webgpu.h")] + [NativeName("Src", "Line 6059, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceGetLimits")] - public unsafe partial Silk.NET.Core.Bool32 DeviceGetLimits(Device* device, SupportedLimits* limits); + public unsafe partial Status DeviceGetLimits(Device* device, Limits* limits); /// To be documented. - [NativeName("Src", "Line 1657, Column 22 in webgpu.h")] + [NativeName("Src", "Line 6059, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceGetLimits")] - public unsafe partial Silk.NET.Core.Bool32 DeviceGetLimits(Device* device, ref SupportedLimits limits); + public unsafe partial Status DeviceGetLimits(Device* device, ref Limits limits); /// To be documented. - [NativeName("Src", "Line 1658, Column 23 in webgpu.h")] + [NativeName("Src", "Line 6064, Column 24 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceGetLostFuture")] + public unsafe partial Future DeviceGetLostFuture(Device* device); + + /// To be documented. + [NativeName("Src", "Line 6069, Column 23 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceGetQueue")] public unsafe partial Queue* DeviceGetQueue(Device* device); /// To be documented. - [NativeName("Src", "Line 1659, Column 22 in webgpu.h")] + [NativeName("Src", "Line 6070, Column 22 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceHasFeature")] public unsafe partial Silk.NET.Core.Bool32 DeviceHasFeature(Device* device, FeatureName feature); /// To be documented. - [NativeName("Src", "Line 1660, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDevicePopErrorScope")] - public unsafe partial void DevicePopErrorScope(Device* device, PfnErrorCallback callback, void* userdata); - - /// To be documented. - [NativeName("Src", "Line 1660, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6075, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDevicePopErrorScope")] - public unsafe partial void DevicePopErrorScope(Device* device, PfnErrorCallback callback, ref T0 userdata) where T0 : unmanaged; + public unsafe partial Future DevicePopErrorScope(Device* device, PopErrorScopeCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1661, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6080, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDevicePushErrorScope")] public unsafe partial void DevicePushErrorScope(Device* device, ErrorFilter filter); /// To be documented. - [NativeName("Src", "Line 1662, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceSetLabel")] - public unsafe partial void DeviceSetLabel(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); - - /// To be documented. - [NativeName("Src", "Line 1662, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceSetLabel")] - public unsafe partial void DeviceSetLabel(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); - - /// To be documented. - [NativeName("Src", "Line 1662, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6081, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceSetLabel")] - public unsafe partial void DeviceSetLabel(Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + public unsafe partial void DeviceSetLabel(Device* device, StringView label); /// To be documented. - [NativeName("Src", "Line 1663, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceSetUncapturedErrorCallback")] - public unsafe partial void DeviceSetUncapturedErrorCallback(Device* device, PfnErrorCallback callback, void* userdata); + [NativeName("Src", "Line 6082, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuDeviceAddRef")] + public unsafe partial void DeviceAddRef(Device* device); /// To be documented. - [NativeName("Src", "Line 1663, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceSetUncapturedErrorCallback")] - public unsafe partial void DeviceSetUncapturedErrorCallback(Device* device, PfnErrorCallback callback, ref T0 userdata) where T0 : unmanaged; - - /// To be documented. - [NativeName("Src", "Line 1664, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuDeviceReference")] - public unsafe partial void DeviceReference(Device* device); - - /// To be documented. - [NativeName("Src", "Line 1665, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6083, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuDeviceRelease")] public unsafe partial void DeviceRelease(Device* device); /// To be documented. - [NativeName("Src", "Line 1668, Column 25 in webgpu.h")] + [NativeName("Src", "Line 6103, Column 25 in webgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceCreateSurface")] public unsafe partial Surface* InstanceCreateSurface(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SurfaceDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1668, Column 25 in webgpu.h")] + [NativeName("Src", "Line 6103, Column 25 in webgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceCreateSurface")] public unsafe partial Surface* InstanceCreateSurface(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly SurfaceDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1669, Column 22 in webgpu.h")] + [NativeName("Src", "Line 6107, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuInstanceGetWGSLLanguageFeatures")] + public unsafe partial void InstanceGetWGSLLanguageFeatures(Instance* instance, SupportedWGSLLanguageFeatures* features); + + /// To be documented. + [NativeName("Src", "Line 6107, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuInstanceGetWGSLLanguageFeatures")] + public unsafe partial void InstanceGetWGSLLanguageFeatures(Instance* instance, ref SupportedWGSLLanguageFeatures features); + + /// To be documented. + [NativeName("Src", "Line 6108, Column 22 in webgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceHasWGSLLanguageFeature")] - public unsafe partial Silk.NET.Core.Bool32 InstanceHasWGSLLanguageFeature(Instance* instance, WGSLFeatureName feature); + public unsafe partial Silk.NET.Core.Bool32 InstanceHasWGSLLanguageFeature(Instance* instance, WGSLLanguageFeatureName feature); /// To be documented. - [NativeName("Src", "Line 1670, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6114, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceProcessEvents")] public unsafe partial void InstanceProcessEvents(Instance* instance); /// To be documented. - [NativeName("Src", "Line 1671, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6115, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceRequestAdapter")] - public unsafe partial void InstanceRequestAdapter(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RequestAdapterOptions* options, PfnRequestAdapterCallback callback, void* userdata); + public unsafe partial Future InstanceRequestAdapter(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RequestAdapterOptions* options, RequestAdapterCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1671, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6115, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceRequestAdapter")] - public unsafe partial void InstanceRequestAdapter(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RequestAdapterOptions* options, PfnRequestAdapterCallback callback, ref T0 userdata) where T0 : unmanaged; + public unsafe partial Future InstanceRequestAdapter(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly RequestAdapterOptions options, RequestAdapterCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1671, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuInstanceRequestAdapter")] - public unsafe partial void InstanceRequestAdapter(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly RequestAdapterOptions options, PfnRequestAdapterCallback callback, void* userdata); + [NativeName("Src", "Line 6121, Column 28 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuInstanceWaitAny")] + public unsafe partial WaitStatus InstanceWaitAny(Instance* instance, nuint futureCount, FutureWaitInfo* futures, ulong timeoutNS); /// To be documented. - [NativeName("Src", "Line 1671, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuInstanceRequestAdapter")] - public unsafe partial void InstanceRequestAdapter(Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly RequestAdapterOptions options, PfnRequestAdapterCallback callback, ref T0 userdata) where T0 : unmanaged; + [NativeName("Src", "Line 6121, Column 28 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuInstanceWaitAny")] + public unsafe partial WaitStatus InstanceWaitAny(Instance* instance, nuint futureCount, ref FutureWaitInfo futures, ulong timeoutNS); /// To be documented. - [NativeName("Src", "Line 1672, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuInstanceReference")] - public unsafe partial void InstanceReference(Instance* instance); + [NativeName("Src", "Line 6122, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuInstanceAddRef")] + public unsafe partial void InstanceAddRef(Instance* instance); /// To be documented. - [NativeName("Src", "Line 1673, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6123, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuInstanceRelease")] public unsafe partial void InstanceRelease(Instance* instance); /// To be documented. - [NativeName("Src", "Line 1676, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6133, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuPipelineLayoutSetLabel")] - public unsafe partial void PipelineLayoutSetLabel(PipelineLayout* pipelineLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + public unsafe partial void PipelineLayoutSetLabel(PipelineLayout* pipelineLayout, StringView label); /// To be documented. - [NativeName("Src", "Line 1676, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuPipelineLayoutSetLabel")] - public unsafe partial void PipelineLayoutSetLabel(PipelineLayout* pipelineLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + [NativeName("Src", "Line 6134, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuPipelineLayoutAddRef")] + public unsafe partial void PipelineLayoutAddRef(PipelineLayout* pipelineLayout); /// To be documented. - [NativeName("Src", "Line 1676, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuPipelineLayoutSetLabel")] - public unsafe partial void PipelineLayoutSetLabel(PipelineLayout* pipelineLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); - - /// To be documented. - [NativeName("Src", "Line 1677, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuPipelineLayoutReference")] - public unsafe partial void PipelineLayoutReference(PipelineLayout* pipelineLayout); - - /// To be documented. - [NativeName("Src", "Line 1678, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6135, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuPipelineLayoutRelease")] public unsafe partial void PipelineLayoutRelease(PipelineLayout* pipelineLayout); /// To be documented. - [NativeName("Src", "Line 1681, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6145, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQuerySetDestroy")] public unsafe partial void QuerySetDestroy(QuerySet* querySet); /// To be documented. - [NativeName("Src", "Line 1682, Column 22 in webgpu.h")] + [NativeName("Src", "Line 6146, Column 22 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQuerySetGetCount")] public unsafe partial uint QuerySetGetCount(QuerySet* querySet); /// To be documented. - [NativeName("Src", "Line 1683, Column 27 in webgpu.h")] + [NativeName("Src", "Line 6147, Column 27 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQuerySetGetType")] public unsafe partial QueryType QuerySetGetType(QuerySet* querySet); /// To be documented. - [NativeName("Src", "Line 1684, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuQuerySetSetLabel")] - public unsafe partial void QuerySetSetLabel(QuerySet* querySet, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); - - /// To be documented. - [NativeName("Src", "Line 1684, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuQuerySetSetLabel")] - public unsafe partial void QuerySetSetLabel(QuerySet* querySet, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); - - /// To be documented. - [NativeName("Src", "Line 1684, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6148, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQuerySetSetLabel")] - public unsafe partial void QuerySetSetLabel(QuerySet* querySet, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + public unsafe partial void QuerySetSetLabel(QuerySet* querySet, StringView label); /// To be documented. - [NativeName("Src", "Line 1685, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuQuerySetReference")] - public unsafe partial void QuerySetReference(QuerySet* querySet); + [NativeName("Src", "Line 6149, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuQuerySetAddRef")] + public unsafe partial void QuerySetAddRef(QuerySet* querySet); /// To be documented. - [NativeName("Src", "Line 1686, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6150, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQuerySetRelease")] public unsafe partial void QuerySetRelease(QuerySet* querySet); /// To be documented. - [NativeName("Src", "Line 1689, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6160, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueOnSubmittedWorkDone")] - public unsafe partial void QueueOnSubmittedWorkDone(Queue* queue, PfnQueueWorkDoneCallback callback, void* userdata); + public unsafe partial Future QueueOnSubmittedWorkDone(Queue* queue, QueueWorkDoneCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1689, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuQueueOnSubmittedWorkDone")] - public unsafe partial void QueueOnSubmittedWorkDone(Queue* queue, PfnQueueWorkDoneCallback callback, ref T0 userdata) where T0 : unmanaged; - - /// To be documented. - [NativeName("Src", "Line 1690, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6161, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueSetLabel")] - public unsafe partial void QueueSetLabel(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + public unsafe partial void QueueSetLabel(Queue* queue, StringView label); /// To be documented. - [NativeName("Src", "Line 1690, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuQueueSetLabel")] - public unsafe partial void QueueSetLabel(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); - - /// To be documented. - [NativeName("Src", "Line 1690, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuQueueSetLabel")] - public unsafe partial void QueueSetLabel(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); - - /// To be documented. - [NativeName("Src", "Line 1691, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6162, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueSubmit")] public unsafe partial void QueueSubmit(Queue* queue, nuint commandCount, CommandBuffer** commands); /// To be documented. - [NativeName("Src", "Line 1691, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6162, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueSubmit")] public unsafe partial void QueueSubmit(Queue* queue, nuint commandCount, ref CommandBuffer* commands); /// To be documented. - [NativeName("Src", "Line 1692, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6167, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteBuffer")] public unsafe partial void QueueWriteBuffer(Queue* queue, Buffer* buffer, ulong bufferOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint size); /// To be documented. - [NativeName("Src", "Line 1692, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6167, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteBuffer")] public unsafe partial void QueueWriteBuffer(Queue* queue, Buffer* buffer, ulong bufferOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint size) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize); /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize); /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueWriteTexture")] - public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ImageCopyTexture destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureDataLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; + public unsafe partial void QueueWriteTexture(Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyTextureInfo destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TexelCopyBufferLayout dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Extent3D writeSize) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1694, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuQueueReference")] - public unsafe partial void QueueReference(Queue* queue); + [NativeName("Src", "Line 6169, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuQueueAddRef")] + public unsafe partial void QueueAddRef(Queue* queue); /// To be documented. - [NativeName("Src", "Line 1695, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6170, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuQueueRelease")] public unsafe partial void QueueRelease(Queue* queue); /// To be documented. - [NativeName("Src", "Line 1698, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleSetLabel")] - public unsafe partial void RenderBundleSetLabel(RenderBundle* renderBundle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); - - /// To be documented. - [NativeName("Src", "Line 1698, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleSetLabel")] - public unsafe partial void RenderBundleSetLabel(RenderBundle* renderBundle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); - - /// To be documented. - [NativeName("Src", "Line 1698, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6180, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleSetLabel")] - public unsafe partial void RenderBundleSetLabel(RenderBundle* renderBundle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + public unsafe partial void RenderBundleSetLabel(RenderBundle* renderBundle, StringView label); /// To be documented. - [NativeName("Src", "Line 1699, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleReference")] - public unsafe partial void RenderBundleReference(RenderBundle* renderBundle); + [NativeName("Src", "Line 6181, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleAddRef")] + public unsafe partial void RenderBundleAddRef(RenderBundle* renderBundle); /// To be documented. - [NativeName("Src", "Line 1700, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6182, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleRelease")] public unsafe partial void RenderBundleRelease(RenderBundle* renderBundle); /// To be documented. - [NativeName("Src", "Line 1703, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6192, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderDraw")] public unsafe partial void RenderBundleEncoderDraw(RenderBundleEncoder* renderBundleEncoder, uint vertexCount, uint instanceCount, uint firstVertex, uint firstInstance); /// To be documented. - [NativeName("Src", "Line 1704, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6193, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderDrawIndexed")] public unsafe partial void RenderBundleEncoderDrawIndexed(RenderBundleEncoder* renderBundleEncoder, uint indexCount, uint instanceCount, uint firstIndex, int baseVertex, uint firstInstance); /// To be documented. - [NativeName("Src", "Line 1705, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6194, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderDrawIndexedIndirect")] public unsafe partial void RenderBundleEncoderDrawIndexedIndirect(RenderBundleEncoder* renderBundleEncoder, Buffer* indirectBuffer, ulong indirectOffset); /// To be documented. - [NativeName("Src", "Line 1706, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6195, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderDrawIndirect")] public unsafe partial void RenderBundleEncoderDrawIndirect(RenderBundleEncoder* renderBundleEncoder, Buffer* indirectBuffer, ulong indirectOffset); /// To be documented. - [NativeName("Src", "Line 1707, Column 30 in webgpu.h")] + [NativeName("Src", "Line 6200, Column 30 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderFinish")] public unsafe partial RenderBundle* RenderBundleEncoderFinish(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RenderBundleDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1707, Column 30 in webgpu.h")] + [NativeName("Src", "Line 6200, Column 30 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderFinish")] public unsafe partial RenderBundle* RenderBundleEncoderFinish(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly RenderBundleDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1708, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleEncoderInsertDebugMarker")] - public unsafe partial void RenderBundleEncoderInsertDebugMarker(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* markerLabel); - - /// To be documented. - [NativeName("Src", "Line 1708, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleEncoderInsertDebugMarker")] - public unsafe partial void RenderBundleEncoderInsertDebugMarker(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte markerLabel); - - /// To be documented. - [NativeName("Src", "Line 1708, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6201, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderInsertDebugMarker")] - public unsafe partial void RenderBundleEncoderInsertDebugMarker(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string markerLabel); + public unsafe partial void RenderBundleEncoderInsertDebugMarker(RenderBundleEncoder* renderBundleEncoder, StringView markerLabel); /// To be documented. - [NativeName("Src", "Line 1709, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6202, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderPopDebugGroup")] public unsafe partial void RenderBundleEncoderPopDebugGroup(RenderBundleEncoder* renderBundleEncoder); /// To be documented. - [NativeName("Src", "Line 1710, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6203, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderPushDebugGroup")] - public unsafe partial void RenderBundleEncoderPushDebugGroup(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* groupLabel); + public unsafe partial void RenderBundleEncoderPushDebugGroup(RenderBundleEncoder* renderBundleEncoder, StringView groupLabel); /// To be documented. - [NativeName("Src", "Line 1710, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleEncoderPushDebugGroup")] - public unsafe partial void RenderBundleEncoderPushDebugGroup(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte groupLabel); - - /// To be documented. - [NativeName("Src", "Line 1710, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleEncoderPushDebugGroup")] - public unsafe partial void RenderBundleEncoderPushDebugGroup(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string groupLabel); - - /// To be documented. - [NativeName("Src", "Line 1711, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6204, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetBindGroup")] public unsafe partial void RenderBundleEncoderSetBindGroup(RenderBundleEncoder* renderBundleEncoder, uint groupIndex, BindGroup* group, nuint dynamicOffsetCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint* dynamicOffsets); /// To be documented. - [NativeName("Src", "Line 1711, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6204, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetBindGroup")] public unsafe partial void RenderBundleEncoderSetBindGroup(RenderBundleEncoder* renderBundleEncoder, uint groupIndex, BindGroup* group, nuint dynamicOffsetCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly uint dynamicOffsets); /// To be documented. - [NativeName("Src", "Line 1712, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6205, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetIndexBuffer")] public unsafe partial void RenderBundleEncoderSetIndexBuffer(RenderBundleEncoder* renderBundleEncoder, Buffer* buffer, IndexFormat format, ulong offset, ulong size); /// To be documented. - [NativeName("Src", "Line 1713, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetLabel")] - public unsafe partial void RenderBundleEncoderSetLabel(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); - - /// To be documented. - [NativeName("Src", "Line 1713, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6206, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetLabel")] - public unsafe partial void RenderBundleEncoderSetLabel(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + public unsafe partial void RenderBundleEncoderSetLabel(RenderBundleEncoder* renderBundleEncoder, StringView label); /// To be documented. - [NativeName("Src", "Line 1713, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetLabel")] - public unsafe partial void RenderBundleEncoderSetLabel(RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); - - /// To be documented. - [NativeName("Src", "Line 1714, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6207, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetPipeline")] public unsafe partial void RenderBundleEncoderSetPipeline(RenderBundleEncoder* renderBundleEncoder, RenderPipeline* pipeline); /// To be documented. - [NativeName("Src", "Line 1715, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6208, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderSetVertexBuffer")] public unsafe partial void RenderBundleEncoderSetVertexBuffer(RenderBundleEncoder* renderBundleEncoder, uint slot, Buffer* buffer, ulong offset, ulong size); /// To be documented. - [NativeName("Src", "Line 1716, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderBundleEncoderReference")] - public unsafe partial void RenderBundleEncoderReference(RenderBundleEncoder* renderBundleEncoder); + [NativeName("Src", "Line 6209, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderBundleEncoderAddRef")] + public unsafe partial void RenderBundleEncoderAddRef(RenderBundleEncoder* renderBundleEncoder); /// To be documented. - [NativeName("Src", "Line 1717, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6210, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderBundleEncoderRelease")] public unsafe partial void RenderBundleEncoderRelease(RenderBundleEncoder* renderBundleEncoder); /// To be documented. - [NativeName("Src", "Line 1720, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6220, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderBeginOcclusionQuery")] public unsafe partial void RenderPassEncoderBeginOcclusionQuery(RenderPassEncoder* renderPassEncoder, uint queryIndex); /// To be documented. - [NativeName("Src", "Line 1721, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6221, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderDraw")] public unsafe partial void RenderPassEncoderDraw(RenderPassEncoder* renderPassEncoder, uint vertexCount, uint instanceCount, uint firstVertex, uint firstInstance); /// To be documented. - [NativeName("Src", "Line 1722, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6222, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderDrawIndexed")] public unsafe partial void RenderPassEncoderDrawIndexed(RenderPassEncoder* renderPassEncoder, uint indexCount, uint instanceCount, uint firstIndex, int baseVertex, uint firstInstance); /// To be documented. - [NativeName("Src", "Line 1723, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6223, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderDrawIndexedIndirect")] public unsafe partial void RenderPassEncoderDrawIndexedIndirect(RenderPassEncoder* renderPassEncoder, Buffer* indirectBuffer, ulong indirectOffset); /// To be documented. - [NativeName("Src", "Line 1724, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6224, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderDrawIndirect")] public unsafe partial void RenderPassEncoderDrawIndirect(RenderPassEncoder* renderPassEncoder, Buffer* indirectBuffer, ulong indirectOffset); /// To be documented. - [NativeName("Src", "Line 1725, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6225, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderEnd")] public unsafe partial void RenderPassEncoderEnd(RenderPassEncoder* renderPassEncoder); /// To be documented. - [NativeName("Src", "Line 1726, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6226, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderEndOcclusionQuery")] public unsafe partial void RenderPassEncoderEndOcclusionQuery(RenderPassEncoder* renderPassEncoder); /// To be documented. - [NativeName("Src", "Line 1727, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6227, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderExecuteBundles")] public unsafe partial void RenderPassEncoderExecuteBundles(RenderPassEncoder* renderPassEncoder, nuint bundleCount, RenderBundle** bundles); /// To be documented. - [NativeName("Src", "Line 1727, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6227, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderExecuteBundles")] public unsafe partial void RenderPassEncoderExecuteBundles(RenderPassEncoder* renderPassEncoder, nuint bundleCount, ref RenderBundle* bundles); /// To be documented. - [NativeName("Src", "Line 1728, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPassEncoderInsertDebugMarker")] - public unsafe partial void RenderPassEncoderInsertDebugMarker(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* markerLabel); - - /// To be documented. - [NativeName("Src", "Line 1728, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPassEncoderInsertDebugMarker")] - public unsafe partial void RenderPassEncoderInsertDebugMarker(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte markerLabel); - - /// To be documented. - [NativeName("Src", "Line 1728, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6228, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderInsertDebugMarker")] - public unsafe partial void RenderPassEncoderInsertDebugMarker(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string markerLabel); + public unsafe partial void RenderPassEncoderInsertDebugMarker(RenderPassEncoder* renderPassEncoder, StringView markerLabel); /// To be documented. - [NativeName("Src", "Line 1729, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6229, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderPopDebugGroup")] public unsafe partial void RenderPassEncoderPopDebugGroup(RenderPassEncoder* renderPassEncoder); /// To be documented. - [NativeName("Src", "Line 1730, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6230, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderPushDebugGroup")] - public unsafe partial void RenderPassEncoderPushDebugGroup(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* groupLabel); + public unsafe partial void RenderPassEncoderPushDebugGroup(RenderPassEncoder* renderPassEncoder, StringView groupLabel); /// To be documented. - [NativeName("Src", "Line 1730, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPassEncoderPushDebugGroup")] - public unsafe partial void RenderPassEncoderPushDebugGroup(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte groupLabel); - - /// To be documented. - [NativeName("Src", "Line 1730, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPassEncoderPushDebugGroup")] - public unsafe partial void RenderPassEncoderPushDebugGroup(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string groupLabel); - - /// To be documented. - [NativeName("Src", "Line 1731, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6231, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetBindGroup")] public unsafe partial void RenderPassEncoderSetBindGroup(RenderPassEncoder* renderPassEncoder, uint groupIndex, BindGroup* group, nuint dynamicOffsetCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint* dynamicOffsets); /// To be documented. - [NativeName("Src", "Line 1731, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6231, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetBindGroup")] public unsafe partial void RenderPassEncoderSetBindGroup(RenderPassEncoder* renderPassEncoder, uint groupIndex, BindGroup* group, nuint dynamicOffsetCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly uint dynamicOffsets); /// To be documented. - [NativeName("Src", "Line 1732, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6236, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetBlendConstant")] public unsafe partial void RenderPassEncoderSetBlendConstant(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color); /// To be documented. - [NativeName("Src", "Line 1732, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6236, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetBlendConstant")] public unsafe partial void RenderPassEncoderSetBlendConstant(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Color color); /// To be documented. - [NativeName("Src", "Line 1733, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6237, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetIndexBuffer")] public unsafe partial void RenderPassEncoderSetIndexBuffer(RenderPassEncoder* renderPassEncoder, Buffer* buffer, IndexFormat format, ulong offset, ulong size); /// To be documented. - [NativeName("Src", "Line 1734, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6238, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetLabel")] - public unsafe partial void RenderPassEncoderSetLabel(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + public unsafe partial void RenderPassEncoderSetLabel(RenderPassEncoder* renderPassEncoder, StringView label); /// To be documented. - [NativeName("Src", "Line 1734, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetLabel")] - public unsafe partial void RenderPassEncoderSetLabel(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); - - /// To be documented. - [NativeName("Src", "Line 1734, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetLabel")] - public unsafe partial void RenderPassEncoderSetLabel(RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); - - /// To be documented. - [NativeName("Src", "Line 1735, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6239, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetPipeline")] public unsafe partial void RenderPassEncoderSetPipeline(RenderPassEncoder* renderPassEncoder, RenderPipeline* pipeline); /// To be documented. - [NativeName("Src", "Line 1736, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6240, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetScissorRect")] public unsafe partial void RenderPassEncoderSetScissorRect(RenderPassEncoder* renderPassEncoder, uint x, uint y, uint width, uint height); /// To be documented. - [NativeName("Src", "Line 1737, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6241, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetStencilReference")] public unsafe partial void RenderPassEncoderSetStencilReference(RenderPassEncoder* renderPassEncoder, uint reference); /// To be documented. - [NativeName("Src", "Line 1738, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6242, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetVertexBuffer")] public unsafe partial void RenderPassEncoderSetVertexBuffer(RenderPassEncoder* renderPassEncoder, uint slot, Buffer* buffer, ulong offset, ulong size); /// To be documented. - [NativeName("Src", "Line 1739, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6248, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderSetViewport")] public unsafe partial void RenderPassEncoderSetViewport(RenderPassEncoder* renderPassEncoder, float x, float y, float width, float height, float minDepth, float maxDepth); /// To be documented. - [NativeName("Src", "Line 1740, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPassEncoderReference")] - public unsafe partial void RenderPassEncoderReference(RenderPassEncoder* renderPassEncoder); + [NativeName("Src", "Line 6249, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPassEncoderAddRef")] + public unsafe partial void RenderPassEncoderAddRef(RenderPassEncoder* renderPassEncoder); /// To be documented. - [NativeName("Src", "Line 1741, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6250, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPassEncoderRelease")] public unsafe partial void RenderPassEncoderRelease(RenderPassEncoder* renderPassEncoder); /// To be documented. - [NativeName("Src", "Line 1744, Column 33 in webgpu.h")] + [NativeName("Src", "Line 6264, Column 33 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPipelineGetBindGroupLayout")] public unsafe partial BindGroupLayout* RenderPipelineGetBindGroupLayout(RenderPipeline* renderPipeline, uint groupIndex); /// To be documented. - [NativeName("Src", "Line 1745, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPipelineSetLabel")] - public unsafe partial void RenderPipelineSetLabel(RenderPipeline* renderPipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); - - /// To be documented. - [NativeName("Src", "Line 1745, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPipelineSetLabel")] - public unsafe partial void RenderPipelineSetLabel(RenderPipeline* renderPipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); - - /// To be documented. - [NativeName("Src", "Line 1745, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6265, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPipelineSetLabel")] - public unsafe partial void RenderPipelineSetLabel(RenderPipeline* renderPipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + public unsafe partial void RenderPipelineSetLabel(RenderPipeline* renderPipeline, StringView label); /// To be documented. - [NativeName("Src", "Line 1746, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuRenderPipelineReference")] - public unsafe partial void RenderPipelineReference(RenderPipeline* renderPipeline); + [NativeName("Src", "Line 6266, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuRenderPipelineAddRef")] + public unsafe partial void RenderPipelineAddRef(RenderPipeline* renderPipeline); /// To be documented. - [NativeName("Src", "Line 1747, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6267, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuRenderPipelineRelease")] public unsafe partial void RenderPipelineRelease(RenderPipeline* renderPipeline); /// To be documented. - [NativeName("Src", "Line 1750, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6277, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSamplerSetLabel")] - public unsafe partial void SamplerSetLabel(Sampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + public unsafe partial void SamplerSetLabel(Sampler* sampler, StringView label); /// To be documented. - [NativeName("Src", "Line 1750, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuSamplerSetLabel")] - public unsafe partial void SamplerSetLabel(Sampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); - - /// To be documented. - [NativeName("Src", "Line 1750, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuSamplerSetLabel")] - public unsafe partial void SamplerSetLabel(Sampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + [NativeName("Src", "Line 6278, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuSamplerAddRef")] + public unsafe partial void SamplerAddRef(Sampler* sampler); /// To be documented. - [NativeName("Src", "Line 1751, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuSamplerReference")] - public unsafe partial void SamplerReference(Sampler* sampler); - - /// To be documented. - [NativeName("Src", "Line 1752, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6279, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSamplerRelease")] public unsafe partial void SamplerRelease(Sampler* sampler); /// To be documented. - [NativeName("Src", "Line 1755, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6289, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuShaderModuleGetCompilationInfo")] - public unsafe partial void ShaderModuleGetCompilationInfo(ShaderModule* shaderModule, PfnCompilationInfoCallback callback, void* userdata); + public unsafe partial Future ShaderModuleGetCompilationInfo(ShaderModule* shaderModule, CompilationInfoCallbackInfo callbackInfo); /// To be documented. - [NativeName("Src", "Line 1755, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuShaderModuleGetCompilationInfo")] - public unsafe partial void ShaderModuleGetCompilationInfo(ShaderModule* shaderModule, PfnCompilationInfoCallback callback, ref T0 userdata) where T0 : unmanaged; + [NativeName("Src", "Line 6290, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuShaderModuleSetLabel")] + public unsafe partial void ShaderModuleSetLabel(ShaderModule* shaderModule, StringView label); /// To be documented. - [NativeName("Src", "Line 1756, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuShaderModuleSetLabel")] - public unsafe partial void ShaderModuleSetLabel(ShaderModule* shaderModule, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); + [NativeName("Src", "Line 6291, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuShaderModuleAddRef")] + public unsafe partial void ShaderModuleAddRef(ShaderModule* shaderModule); /// To be documented. - [NativeName("Src", "Line 1756, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuShaderModuleSetLabel")] - public unsafe partial void ShaderModuleSetLabel(ShaderModule* shaderModule, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + [NativeName("Src", "Line 6292, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuShaderModuleRelease")] + public unsafe partial void ShaderModuleRelease(ShaderModule* shaderModule); /// To be documented. - [NativeName("Src", "Line 1756, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuShaderModuleSetLabel")] - public unsafe partial void ShaderModuleSetLabel(ShaderModule* shaderModule, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + [NativeName("Src", "Line 6305, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuSupportedFeaturesFreeMembers")] + public partial void SupportedFeaturesFreeMembers(SupportedFeatures supportedFeatures); /// To be documented. - [NativeName("Src", "Line 1757, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuShaderModuleReference")] - public unsafe partial void ShaderModuleReference(ShaderModule* shaderModule); + [NativeName("Src", "Line 6318, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuSupportedInstanceFeaturesFreeMembers")] + public partial void SupportedInstanceFeaturesFreeMembers(SupportedInstanceFeatures supportedInstanceFeatures); /// To be documented. - [NativeName("Src", "Line 1758, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuShaderModuleRelease")] - public unsafe partial void ShaderModuleRelease(ShaderModule* shaderModule); + [NativeName("Src", "Line 6331, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuSupportedWGSLLanguageFeaturesFreeMembers")] + public partial void SupportedWGSLLanguageFeaturesFreeMembers(SupportedWGSLLanguageFeatures supportedWGSLLanguageFeatures); /// To be documented. - [NativeName("Src", "Line 1761, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6350, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSurfaceConfigure")] public unsafe partial void SurfaceConfigure(Surface* surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SurfaceConfiguration* config); /// To be documented. - [NativeName("Src", "Line 1761, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6350, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSurfaceConfigure")] public unsafe partial void SurfaceConfigure(Surface* surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly SurfaceConfiguration config); /// To be documented. - [NativeName("Src", "Line 1762, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6366, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSurfaceGetCapabilities")] - public unsafe partial void SurfaceGetCapabilities(Surface* surface, Adapter* adapter, SurfaceCapabilities* capabilities); + public unsafe partial Status SurfaceGetCapabilities(Surface* surface, Adapter* adapter, SurfaceCapabilities* capabilities); /// To be documented. - [NativeName("Src", "Line 1762, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6366, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSurfaceGetCapabilities")] - public unsafe partial void SurfaceGetCapabilities(Surface* surface, Adapter* adapter, ref SurfaceCapabilities capabilities); + public unsafe partial Status SurfaceGetCapabilities(Surface* surface, Adapter* adapter, ref SurfaceCapabilities capabilities); /// To be documented. - [NativeName("Src", "Line 1763, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6376, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSurfaceGetCurrentTexture")] public unsafe partial void SurfaceGetCurrentTexture(Surface* surface, SurfaceTexture* surfaceTexture); /// To be documented. - [NativeName("Src", "Line 1763, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6376, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSurfaceGetCurrentTexture")] public unsafe partial void SurfaceGetCurrentTexture(Surface* surface, ref SurfaceTexture surfaceTexture); /// To be documented. - [NativeName("Src", "Line 1764, Column 31 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuSurfaceGetPreferredFormat")] - public unsafe partial TextureFormat SurfaceGetPreferredFormat(Surface* surface, Adapter* adapter); - - /// To be documented. - [NativeName("Src", "Line 1765, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6384, Column 24 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSurfacePresent")] - public unsafe partial void SurfacePresent(Surface* surface); - - /// To be documented. - [NativeName("Src", "Line 1766, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuSurfaceSetLabel")] - public unsafe partial void SurfaceSetLabel(Surface* surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); - - /// To be documented. - [NativeName("Src", "Line 1766, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuSurfaceSetLabel")] - public unsafe partial void SurfaceSetLabel(Surface* surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); + public unsafe partial Status SurfacePresent(Surface* surface); /// To be documented. - [NativeName("Src", "Line 1766, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6391, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSurfaceSetLabel")] - public unsafe partial void SurfaceSetLabel(Surface* surface, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + public unsafe partial void SurfaceSetLabel(Surface* surface, StringView label); /// To be documented. - [NativeName("Src", "Line 1767, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6396, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSurfaceUnconfigure")] public unsafe partial void SurfaceUnconfigure(Surface* surface); /// To be documented. - [NativeName("Src", "Line 1768, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuSurfaceReference")] - public unsafe partial void SurfaceReference(Surface* surface); + [NativeName("Src", "Line 6397, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuSurfaceAddRef")] + public unsafe partial void SurfaceAddRef(Surface* surface); /// To be documented. - [NativeName("Src", "Line 1769, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6398, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSurfaceRelease")] public unsafe partial void SurfaceRelease(Surface* surface); /// To be documented. - [NativeName("Src", "Line 1772, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6411, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuSurfaceCapabilitiesFreeMembers")] public partial void SurfaceCapabilitiesFreeMembers(SurfaceCapabilities surfaceCapabilities); /// To be documented. - [NativeName("Src", "Line 1775, Column 29 in webgpu.h")] + [NativeName("Src", "Line 6425, Column 29 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureCreateView")] public unsafe partial TextureView* TextureCreateView(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureViewDescriptor* descriptor); /// To be documented. - [NativeName("Src", "Line 1775, Column 29 in webgpu.h")] + [NativeName("Src", "Line 6425, Column 29 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureCreateView")] public unsafe partial TextureView* TextureCreateView(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly TextureViewDescriptor descriptor); /// To be documented. - [NativeName("Src", "Line 1776, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6426, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureDestroy")] public unsafe partial void TextureDestroy(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1777, Column 22 in webgpu.h")] + [NativeName("Src", "Line 6427, Column 22 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureGetDepthOrArrayLayers")] public unsafe partial uint TextureGetDepthOrArrayLayers(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1778, Column 34 in webgpu.h")] + [NativeName("Src", "Line 6428, Column 34 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureGetDimension")] public unsafe partial TextureDimension TextureGetDimension(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1779, Column 31 in webgpu.h")] + [NativeName("Src", "Line 6429, Column 31 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureGetFormat")] public unsafe partial TextureFormat TextureGetFormat(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1780, Column 22 in webgpu.h")] + [NativeName("Src", "Line 6430, Column 22 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureGetHeight")] public unsafe partial uint TextureGetHeight(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1781, Column 22 in webgpu.h")] + [NativeName("Src", "Line 6431, Column 22 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureGetMipLevelCount")] public unsafe partial uint TextureGetMipLevelCount(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1782, Column 22 in webgpu.h")] + [NativeName("Src", "Line 6432, Column 22 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureGetSampleCount")] public unsafe partial uint TextureGetSampleCount(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1783, Column 35 in webgpu.h")] + [NativeName("Src", "Line 6433, Column 30 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureGetUsage")] - public unsafe partial Silk.NET.WebGPU.TextureUsage TextureGetUsage(Texture* texture); + public unsafe partial ulong TextureGetUsage(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1784, Column 22 in webgpu.h")] + [NativeName("Src", "Line 6434, Column 22 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureGetWidth")] public unsafe partial uint TextureGetWidth(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1785, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuTextureSetLabel")] - public unsafe partial void TextureSetLabel(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); - - /// To be documented. - [NativeName("Src", "Line 1785, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuTextureSetLabel")] - public unsafe partial void TextureSetLabel(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); - - /// To be documented. - [NativeName("Src", "Line 1785, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6435, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureSetLabel")] - public unsafe partial void TextureSetLabel(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + public unsafe partial void TextureSetLabel(Texture* texture, StringView label); /// To be documented. - [NativeName("Src", "Line 1786, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuTextureReference")] - public unsafe partial void TextureReference(Texture* texture); + [NativeName("Src", "Line 6436, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuTextureAddRef")] + public unsafe partial void TextureAddRef(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1787, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6437, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureRelease")] public unsafe partial void TextureRelease(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1790, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuTextureViewSetLabel")] - public unsafe partial void TextureViewSetLabel(TextureView* textureView, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* label); - - /// To be documented. - [NativeName("Src", "Line 1790, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuTextureViewSetLabel")] - public unsafe partial void TextureViewSetLabel(TextureView* textureView, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte label); - - /// To be documented. - [NativeName("Src", "Line 1790, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6447, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureViewSetLabel")] - public unsafe partial void TextureViewSetLabel(TextureView* textureView, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string label); + public unsafe partial void TextureViewSetLabel(TextureView* textureView, StringView label); /// To be documented. - [NativeName("Src", "Line 1791, Column 18 in webgpu.h")] - [NativeApi(EntryPoint = "wgpuTextureViewReference")] - public unsafe partial void TextureViewReference(TextureView* textureView); + [NativeName("Src", "Line 6448, Column 18 in webgpu.h")] + [NativeApi(EntryPoint = "wgpuTextureViewAddRef")] + public unsafe partial void TextureViewAddRef(TextureView* textureView); /// To be documented. - [NativeName("Src", "Line 1792, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6449, Column 18 in webgpu.h")] [NativeApi(EntryPoint = "wgpuTextureViewRelease")] public unsafe partial void TextureViewRelease(TextureView* textureView); diff --git a/src/WebGPU/Silk.NET.WebGPU/WebGPUOverloads.gen.cs b/src/WebGPU/Silk.NET.WebGPU/WebGPUOverloads.gen.cs index 687f014361..f71484420c 100644 --- a/src/WebGPU/Silk.NET.WebGPU/WebGPUOverloads.gen.cs +++ b/src/WebGPU/Silk.NET.WebGPU/WebGPUOverloads.gen.cs @@ -17,7 +17,7 @@ namespace Silk.NET.WebGPU public static class WebGPUOverloads { /// To be documented. - [NativeName("Src", "Line 1562, Column 26 in webgpu.h")] + [NativeName("Src", "Line 5673, Column 26 in webgpu.h")] public static unsafe Instance* CreateInstance(this WebGPU thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -25,111 +25,71 @@ public static class WebGPUOverloads } /// To be documented. - [NativeName("Src", "Line 1563, Column 22 in webgpu.h")] - public static unsafe PfnProc GetProcAddress(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan procName) + [NativeName("Src", "Line 5680, Column 18 in webgpu.h")] + public static unsafe void GetInstanceFeatures(this WebGPU thisApi, Span features) { // SpanOverloader - return thisApi.GetProcAddress(device, in procName.GetPinnableReference()); + thisApi.GetInstanceFeatures(ref features.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1566, Column 20 in webgpu.h")] - public static unsafe nuint AdapterEnumerateFeatures(this WebGPU thisApi, Adapter* adapter, Span features) + [NativeName("Src", "Line 5687, Column 24 in webgpu.h")] + public static unsafe Status GetInstanceLimits(this WebGPU thisApi, Span limits) { // SpanOverloader - return thisApi.AdapterEnumerateFeatures(adapter, ref features.GetPinnableReference()); + return thisApi.GetInstanceLimits(ref limits.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1567, Column 22 in webgpu.h")] - public static unsafe Silk.NET.Core.Bool32 AdapterGetLimits(this WebGPU thisApi, Adapter* adapter, Span limits) + [NativeName("Src", "Line 5719, Column 18 in webgpu.h")] + public static unsafe void AdapterGetFeatures(this WebGPU thisApi, Adapter* adapter, Span features) { // SpanOverloader - return thisApi.AdapterGetLimits(adapter, ref limits.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1568, Column 18 in webgpu.h")] - public static unsafe void AdapterGetProperties(this WebGPU thisApi, Adapter* adapter, Span properties) - { - // SpanOverloader - thisApi.AdapterGetProperties(adapter, ref properties.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1570, Column 18 in webgpu.h")] - public static unsafe void AdapterRequestAdapterInfo(this WebGPU thisApi, Adapter* adapter, PfnAdapterRequestAdapterInfoCallback callback, Span userdata) where T0 : unmanaged - { - // SpanOverloader - thisApi.AdapterRequestAdapterInfo(adapter, callback, ref userdata.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1571, Column 18 in webgpu.h")] - public static unsafe void AdapterRequestDevice(this WebGPU thisApi, Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DeviceDescriptor* descriptor, PfnRequestDeviceCallback callback, Span userdata) where T0 : unmanaged - { - // SpanOverloader - thisApi.AdapterRequestDevice(adapter, descriptor, callback, ref userdata.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1571, Column 18 in webgpu.h")] - public static unsafe void AdapterRequestDevice(this WebGPU thisApi, Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor, PfnRequestDeviceCallback callback, void* userdata) - { - // SpanOverloader - thisApi.AdapterRequestDevice(adapter, in descriptor.GetPinnableReference(), callback, userdata); - } - - /// To be documented. - [NativeName("Src", "Line 1571, Column 18 in webgpu.h")] - public static unsafe void AdapterRequestDevice(this WebGPU thisApi, Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor, PfnRequestDeviceCallback callback, Span userdata) where T0 : unmanaged - { - // SpanOverloader - thisApi.AdapterRequestDevice(adapter, in descriptor.GetPinnableReference(), callback, ref userdata.GetPinnableReference()); + thisApi.AdapterGetFeatures(adapter, ref features.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1576, Column 18 in webgpu.h")] - public static unsafe void BindGroupSetLabel(this WebGPU thisApi, BindGroup* bindGroup, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) + [NativeName("Src", "Line 5727, Column 24 in webgpu.h")] + public static unsafe Status AdapterGetInfo(this WebGPU thisApi, Adapter* adapter, Span info) { // SpanOverloader - thisApi.BindGroupSetLabel(bindGroup, in label.GetPinnableReference()); + return thisApi.AdapterGetInfo(adapter, ref info.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1581, Column 18 in webgpu.h")] - public static unsafe void BindGroupLayoutSetLabel(this WebGPU thisApi, BindGroupLayout* bindGroupLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) + [NativeName("Src", "Line 5732, Column 24 in webgpu.h")] + public static unsafe Status AdapterGetLimits(this WebGPU thisApi, Adapter* adapter, Span limits) { // SpanOverloader - thisApi.BindGroupLayoutSetLabel(bindGroupLayout, in label.GetPinnableReference()); + return thisApi.AdapterGetLimits(adapter, ref limits.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1592, Column 18 in webgpu.h")] - public static unsafe void BufferMapAsync(this WebGPU thisApi, Buffer* buffer, Silk.NET.WebGPU.MapMode mode, nuint offset, nuint size, PfnBufferMapCallback callback, Span userdata) where T0 : unmanaged + [NativeName("Src", "Line 5734, Column 24 in webgpu.h")] + public static unsafe Future AdapterRequestDevice(this WebGPU thisApi, Adapter* adapter, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor, RequestDeviceCallbackInfo callbackInfo) { // SpanOverloader - thisApi.BufferMapAsync(buffer, mode, offset, size, callback, ref userdata.GetPinnableReference()); + return thisApi.AdapterRequestDevice(adapter, in descriptor.GetPinnableReference(), callbackInfo); } /// To be documented. - [NativeName("Src", "Line 1593, Column 18 in webgpu.h")] - public static unsafe void BufferSetLabel(this WebGPU thisApi, Buffer* buffer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) + [NativeName("Src", "Line 5851, Column 24 in webgpu.h")] + public static unsafe Status BufferReadMappedRange(this WebGPU thisApi, Buffer* buffer, nuint offset, Span data, nuint size) where T0 : unmanaged { // SpanOverloader - thisApi.BufferSetLabel(buffer, in label.GetPinnableReference()); + return thisApi.BufferReadMappedRange(buffer, offset, ref data.GetPinnableReference(), size); } /// To be documented. - [NativeName("Src", "Line 1599, Column 18 in webgpu.h")] - public static unsafe void CommandBufferSetLabel(this WebGPU thisApi, CommandBuffer* commandBuffer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) + [NativeName("Src", "Line 5874, Column 24 in webgpu.h")] + public static unsafe Status BufferWriteMappedRange(this WebGPU thisApi, Buffer* buffer, nuint offset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint size) where T0 : unmanaged { // SpanOverloader - thisApi.CommandBufferSetLabel(commandBuffer, in label.GetPinnableReference()); + return thisApi.BufferWriteMappedRange(buffer, offset, in data.GetPinnableReference(), size); } /// To be documented. - [NativeName("Src", "Line 1604, Column 36 in webgpu.h")] + [NativeName("Src", "Line 5902, Column 36 in webgpu.h")] public static unsafe ComputePassEncoder* CommandEncoderBeginComputePass(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -137,7 +97,7 @@ public static unsafe void CommandBufferSetLabel(this WebGPU thisApi, CommandBuff } /// To be documented. - [NativeName("Src", "Line 1605, Column 35 in webgpu.h")] + [NativeName("Src", "Line 5907, Column 35 in webgpu.h")] public static unsafe RenderPassEncoder* CommandEncoderBeginRenderPass(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -145,175 +105,175 @@ public static unsafe void CommandBufferSetLabel(this WebGPU thisApi, CommandBuff } /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyBufferToTexture(commandEncoder, source, destination, in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) { // SpanOverloader thisApi.CommandEncoderCopyBufferToTexture(commandEncoder, source, in destination.GetPinnableReference(), copySize); } /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyBufferToTexture(commandEncoder, source, in destination.GetPinnableReference(), in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) { // SpanOverloader thisApi.CommandEncoderCopyBufferToTexture(commandEncoder, in source.GetPinnableReference(), destination, copySize); } /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyBufferToTexture(commandEncoder, in source.GetPinnableReference(), destination, in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) { // SpanOverloader thisApi.CommandEncoderCopyBufferToTexture(commandEncoder, in source.GetPinnableReference(), in destination.GetPinnableReference(), copySize); } /// To be documented. - [NativeName("Src", "Line 1608, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5910, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyBufferToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyBufferToTexture(commandEncoder, in source.GetPinnableReference(), in destination.GetPinnableReference(), in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToBuffer(commandEncoder, source, destination, in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToBuffer(commandEncoder, source, in destination.GetPinnableReference(), copySize); } /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToBuffer(commandEncoder, source, in destination.GetPinnableReference(), in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToBuffer(commandEncoder, in source.GetPinnableReference(), destination, copySize); } /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyBuffer* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToBuffer(commandEncoder, in source.GetPinnableReference(), destination, in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToBuffer(commandEncoder, in source.GetPinnableReference(), in destination.GetPinnableReference(), copySize); } /// To be documented. - [NativeName("Src", "Line 1609, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5911, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToBuffer(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToBuffer(commandEncoder, in source.GetPinnableReference(), in destination.GetPinnableReference(), in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToTexture(commandEncoder, source, destination, in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToTexture(commandEncoder, source, in destination.GetPinnableReference(), copySize); } /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToTexture(commandEncoder, source, in destination.GetPinnableReference(), in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToTexture(commandEncoder, in source.GetPinnableReference(), destination, copySize); } /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToTexture(commandEncoder, in source.GetPinnableReference(), destination, in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToTexture(commandEncoder, in source.GetPinnableReference(), in destination.GetPinnableReference(), copySize); } /// To be documented. - [NativeName("Src", "Line 1610, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) + [NativeName("Src", "Line 5912, Column 18 in webgpu.h")] + public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan source, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan copySize) { // SpanOverloader thisApi.CommandEncoderCopyTextureToTexture(commandEncoder, in source.GetPinnableReference(), in destination.GetPinnableReference(), in copySize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1611, Column 31 in webgpu.h")] + [NativeName("Src", "Line 5917, Column 31 in webgpu.h")] public static unsafe CommandBuffer* CommandEncoderFinish(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -321,47 +281,7 @@ public static unsafe void CommandEncoderCopyTextureToTexture(this WebGPU thisApi } /// To be documented. - [NativeName("Src", "Line 1612, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderInsertDebugMarker(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerLabel) - { - // SpanOverloader - thisApi.CommandEncoderInsertDebugMarker(commandEncoder, in markerLabel.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1614, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderPushDebugGroup(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan groupLabel) - { - // SpanOverloader - thisApi.CommandEncoderPushDebugGroup(commandEncoder, in groupLabel.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1616, Column 18 in webgpu.h")] - public static unsafe void CommandEncoderSetLabel(this WebGPU thisApi, CommandEncoder* commandEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.CommandEncoderSetLabel(commandEncoder, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1625, Column 18 in webgpu.h")] - public static unsafe void ComputePassEncoderInsertDebugMarker(this WebGPU thisApi, ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerLabel) - { - // SpanOverloader - thisApi.ComputePassEncoderInsertDebugMarker(computePassEncoder, in markerLabel.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1627, Column 18 in webgpu.h")] - public static unsafe void ComputePassEncoderPushDebugGroup(this WebGPU thisApi, ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan groupLabel) - { - // SpanOverloader - thisApi.ComputePassEncoderPushDebugGroup(computePassEncoder, in groupLabel.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1628, Column 18 in webgpu.h")] + [NativeName("Src", "Line 5941, Column 18 in webgpu.h")] public static unsafe void ComputePassEncoderSetBindGroup(this WebGPU thisApi, ComputePassEncoder* computePassEncoder, uint groupIndex, BindGroup* group, nuint dynamicOffsetCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dynamicOffsets) { // SpanOverloader @@ -369,23 +289,7 @@ public static unsafe void ComputePassEncoderSetBindGroup(this WebGPU thisApi, Co } /// To be documented. - [NativeName("Src", "Line 1629, Column 18 in webgpu.h")] - public static unsafe void ComputePassEncoderSetLabel(this WebGPU thisApi, ComputePassEncoder* computePassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.ComputePassEncoderSetLabel(computePassEncoder, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1636, Column 18 in webgpu.h")] - public static unsafe void ComputePipelineSetLabel(this WebGPU thisApi, ComputePipeline* computePipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.ComputePipelineSetLabel(computePipeline, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1641, Column 27 in webgpu.h")] + [NativeName("Src", "Line 5976, Column 27 in webgpu.h")] public static unsafe BindGroup* DeviceCreateBindGroup(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -393,7 +297,7 @@ public static unsafe void ComputePipelineSetLabel(this WebGPU thisApi, ComputePi } /// To be documented. - [NativeName("Src", "Line 1642, Column 33 in webgpu.h")] + [NativeName("Src", "Line 5981, Column 33 in webgpu.h")] public static unsafe BindGroupLayout* DeviceCreateBindGroupLayout(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -401,7 +305,7 @@ public static unsafe void ComputePipelineSetLabel(this WebGPU thisApi, ComputePi } /// To be documented. - [NativeName("Src", "Line 1643, Column 24 in webgpu.h")] + [NativeName("Src", "Line 5991, Column 38 in webgpu.h")] public static unsafe Buffer* DeviceCreateBuffer(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -409,7 +313,7 @@ public static unsafe void ComputePipelineSetLabel(this WebGPU thisApi, ComputePi } /// To be documented. - [NativeName("Src", "Line 1644, Column 32 in webgpu.h")] + [NativeName("Src", "Line 5996, Column 32 in webgpu.h")] public static unsafe CommandEncoder* DeviceCreateCommandEncoder(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -417,7 +321,7 @@ public static unsafe void ComputePipelineSetLabel(this WebGPU thisApi, ComputePi } /// To be documented. - [NativeName("Src", "Line 1645, Column 33 in webgpu.h")] + [NativeName("Src", "Line 6001, Column 33 in webgpu.h")] public static unsafe ComputePipeline* DeviceCreateComputePipeline(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -425,31 +329,15 @@ public static unsafe void ComputePipelineSetLabel(this WebGPU thisApi, ComputePi } /// To be documented. - [NativeName("Src", "Line 1646, Column 18 in webgpu.h")] - public static unsafe void DeviceCreateComputePipelineAsync(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ComputePipelineDescriptor* descriptor, PfnCreateComputePipelineAsyncCallback callback, Span userdata) where T0 : unmanaged - { - // SpanOverloader - thisApi.DeviceCreateComputePipelineAsync(device, descriptor, callback, ref userdata.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1646, Column 18 in webgpu.h")] - public static unsafe void DeviceCreateComputePipelineAsync(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor, PfnCreateComputePipelineAsyncCallback callback, void* userdata) - { - // SpanOverloader - thisApi.DeviceCreateComputePipelineAsync(device, in descriptor.GetPinnableReference(), callback, userdata); - } - - /// To be documented. - [NativeName("Src", "Line 1646, Column 18 in webgpu.h")] - public static unsafe void DeviceCreateComputePipelineAsync(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor, PfnCreateComputePipelineAsyncCallback callback, Span userdata) where T0 : unmanaged + [NativeName("Src", "Line 6002, Column 24 in webgpu.h")] + public static unsafe Future DeviceCreateComputePipelineAsync(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor, CreateComputePipelineAsyncCallbackInfo callbackInfo) { // SpanOverloader - thisApi.DeviceCreateComputePipelineAsync(device, in descriptor.GetPinnableReference(), callback, ref userdata.GetPinnableReference()); + return thisApi.DeviceCreateComputePipelineAsync(device, in descriptor.GetPinnableReference(), callbackInfo); } /// To be documented. - [NativeName("Src", "Line 1647, Column 32 in webgpu.h")] + [NativeName("Src", "Line 6007, Column 32 in webgpu.h")] public static unsafe PipelineLayout* DeviceCreatePipelineLayout(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -457,7 +345,7 @@ public static unsafe void DeviceCreateComputePipelineAsync(this WebGPU thisA } /// To be documented. - [NativeName("Src", "Line 1648, Column 26 in webgpu.h")] + [NativeName("Src", "Line 6012, Column 26 in webgpu.h")] public static unsafe QuerySet* DeviceCreateQuerySet(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -465,7 +353,7 @@ public static unsafe void DeviceCreateComputePipelineAsync(this WebGPU thisA } /// To be documented. - [NativeName("Src", "Line 1649, Column 37 in webgpu.h")] + [NativeName("Src", "Line 6017, Column 37 in webgpu.h")] public static unsafe RenderBundleEncoder* DeviceCreateRenderBundleEncoder(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -473,7 +361,7 @@ public static unsafe void DeviceCreateComputePipelineAsync(this WebGPU thisA } /// To be documented. - [NativeName("Src", "Line 1650, Column 32 in webgpu.h")] + [NativeName("Src", "Line 6022, Column 32 in webgpu.h")] public static unsafe RenderPipeline* DeviceCreateRenderPipeline(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -481,31 +369,15 @@ public static unsafe void DeviceCreateComputePipelineAsync(this WebGPU thisA } /// To be documented. - [NativeName("Src", "Line 1651, Column 18 in webgpu.h")] - public static unsafe void DeviceCreateRenderPipelineAsync(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RenderPipelineDescriptor* descriptor, PfnCreateRenderPipelineAsyncCallback callback, Span userdata) where T0 : unmanaged - { - // SpanOverloader - thisApi.DeviceCreateRenderPipelineAsync(device, descriptor, callback, ref userdata.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1651, Column 18 in webgpu.h")] - public static unsafe void DeviceCreateRenderPipelineAsync(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor, PfnCreateRenderPipelineAsyncCallback callback, void* userdata) + [NativeName("Src", "Line 6023, Column 24 in webgpu.h")] + public static unsafe Future DeviceCreateRenderPipelineAsync(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor, CreateRenderPipelineAsyncCallbackInfo callbackInfo) { // SpanOverloader - thisApi.DeviceCreateRenderPipelineAsync(device, in descriptor.GetPinnableReference(), callback, userdata); + return thisApi.DeviceCreateRenderPipelineAsync(device, in descriptor.GetPinnableReference(), callbackInfo); } /// To be documented. - [NativeName("Src", "Line 1651, Column 18 in webgpu.h")] - public static unsafe void DeviceCreateRenderPipelineAsync(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor, PfnCreateRenderPipelineAsyncCallback callback, Span userdata) where T0 : unmanaged - { - // SpanOverloader - thisApi.DeviceCreateRenderPipelineAsync(device, in descriptor.GetPinnableReference(), callback, ref userdata.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1652, Column 25 in webgpu.h")] + [NativeName("Src", "Line 6028, Column 25 in webgpu.h")] public static unsafe Sampler* DeviceCreateSampler(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -513,7 +385,7 @@ public static unsafe void DeviceCreateRenderPipelineAsync(this WebGPU thisAp } /// To be documented. - [NativeName("Src", "Line 1653, Column 30 in webgpu.h")] + [NativeName("Src", "Line 6033, Column 30 in webgpu.h")] public static unsafe ShaderModule* DeviceCreateShaderModule(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -521,7 +393,7 @@ public static unsafe void DeviceCreateRenderPipelineAsync(this WebGPU thisAp } /// To be documented. - [NativeName("Src", "Line 1654, Column 25 in webgpu.h")] + [NativeName("Src", "Line 6038, Column 25 in webgpu.h")] public static unsafe Texture* DeviceCreateTexture(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -529,47 +401,31 @@ public static unsafe void DeviceCreateRenderPipelineAsync(this WebGPU thisAp } /// To be documented. - [NativeName("Src", "Line 1656, Column 20 in webgpu.h")] - public static unsafe nuint DeviceEnumerateFeatures(this WebGPU thisApi, Device* device, Span features) - { - // SpanOverloader - return thisApi.DeviceEnumerateFeatures(device, ref features.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1657, Column 22 in webgpu.h")] - public static unsafe Silk.NET.Core.Bool32 DeviceGetLimits(this WebGPU thisApi, Device* device, Span limits) - { - // SpanOverloader - return thisApi.DeviceGetLimits(device, ref limits.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1660, Column 18 in webgpu.h")] - public static unsafe void DevicePopErrorScope(this WebGPU thisApi, Device* device, PfnErrorCallback callback, Span userdata) where T0 : unmanaged + [NativeName("Src", "Line 6047, Column 24 in webgpu.h")] + public static unsafe Status DeviceGetAdapterInfo(this WebGPU thisApi, Device* device, Span adapterInfo) { // SpanOverloader - thisApi.DevicePopErrorScope(device, callback, ref userdata.GetPinnableReference()); + return thisApi.DeviceGetAdapterInfo(device, ref adapterInfo.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1662, Column 18 in webgpu.h")] - public static unsafe void DeviceSetLabel(this WebGPU thisApi, Device* device, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) + [NativeName("Src", "Line 6054, Column 18 in webgpu.h")] + public static unsafe void DeviceGetFeatures(this WebGPU thisApi, Device* device, Span features) { // SpanOverloader - thisApi.DeviceSetLabel(device, in label.GetPinnableReference()); + thisApi.DeviceGetFeatures(device, ref features.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1663, Column 18 in webgpu.h")] - public static unsafe void DeviceSetUncapturedErrorCallback(this WebGPU thisApi, Device* device, PfnErrorCallback callback, Span userdata) where T0 : unmanaged + [NativeName("Src", "Line 6059, Column 24 in webgpu.h")] + public static unsafe Status DeviceGetLimits(this WebGPU thisApi, Device* device, Span limits) { // SpanOverloader - thisApi.DeviceSetUncapturedErrorCallback(device, callback, ref userdata.GetPinnableReference()); + return thisApi.DeviceGetLimits(device, ref limits.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1668, Column 25 in webgpu.h")] + [NativeName("Src", "Line 6103, Column 25 in webgpu.h")] public static unsafe Surface* InstanceCreateSurface(this WebGPU thisApi, Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -577,63 +433,31 @@ public static unsafe void DeviceSetUncapturedErrorCallback(this WebGPU thisA } /// To be documented. - [NativeName("Src", "Line 1671, Column 18 in webgpu.h")] - public static unsafe void InstanceRequestAdapter(this WebGPU thisApi, Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RequestAdapterOptions* options, PfnRequestAdapterCallback callback, Span userdata) where T0 : unmanaged - { - // SpanOverloader - thisApi.InstanceRequestAdapter(instance, options, callback, ref userdata.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1671, Column 18 in webgpu.h")] - public static unsafe void InstanceRequestAdapter(this WebGPU thisApi, Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan options, PfnRequestAdapterCallback callback, void* userdata) - { - // SpanOverloader - thisApi.InstanceRequestAdapter(instance, in options.GetPinnableReference(), callback, userdata); - } - - /// To be documented. - [NativeName("Src", "Line 1671, Column 18 in webgpu.h")] - public static unsafe void InstanceRequestAdapter(this WebGPU thisApi, Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan options, PfnRequestAdapterCallback callback, Span userdata) where T0 : unmanaged + [NativeName("Src", "Line 6107, Column 18 in webgpu.h")] + public static unsafe void InstanceGetWGSLLanguageFeatures(this WebGPU thisApi, Instance* instance, Span features) { // SpanOverloader - thisApi.InstanceRequestAdapter(instance, in options.GetPinnableReference(), callback, ref userdata.GetPinnableReference()); + thisApi.InstanceGetWGSLLanguageFeatures(instance, ref features.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1676, Column 18 in webgpu.h")] - public static unsafe void PipelineLayoutSetLabel(this WebGPU thisApi, PipelineLayout* pipelineLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) + [NativeName("Src", "Line 6115, Column 24 in webgpu.h")] + public static unsafe Future InstanceRequestAdapter(this WebGPU thisApi, Instance* instance, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan options, RequestAdapterCallbackInfo callbackInfo) { // SpanOverloader - thisApi.PipelineLayoutSetLabel(pipelineLayout, in label.GetPinnableReference()); + return thisApi.InstanceRequestAdapter(instance, in options.GetPinnableReference(), callbackInfo); } /// To be documented. - [NativeName("Src", "Line 1684, Column 18 in webgpu.h")] - public static unsafe void QuerySetSetLabel(this WebGPU thisApi, QuerySet* querySet, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) + [NativeName("Src", "Line 6121, Column 28 in webgpu.h")] + public static unsafe WaitStatus InstanceWaitAny(this WebGPU thisApi, Instance* instance, nuint futureCount, Span futures, ulong timeoutNS) { // SpanOverloader - thisApi.QuerySetSetLabel(querySet, in label.GetPinnableReference()); + return thisApi.InstanceWaitAny(instance, futureCount, ref futures.GetPinnableReference(), timeoutNS); } /// To be documented. - [NativeName("Src", "Line 1689, Column 18 in webgpu.h")] - public static unsafe void QueueOnSubmittedWorkDone(this WebGPU thisApi, Queue* queue, PfnQueueWorkDoneCallback callback, Span userdata) where T0 : unmanaged - { - // SpanOverloader - thisApi.QueueOnSubmittedWorkDone(queue, callback, ref userdata.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1690, Column 18 in webgpu.h")] - public static unsafe void QueueSetLabel(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.QueueSetLabel(queue, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1692, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6167, Column 18 in webgpu.h")] public static unsafe void QueueWriteBuffer(this WebGPU thisApi, Queue* queue, Buffer* buffer, ulong bufferOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint size) where T0 : unmanaged { // SpanOverloader @@ -641,135 +465,127 @@ public static unsafe void QueueWriteBuffer(this WebGPU thisApi, Queue* queue } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) { // SpanOverloader thisApi.QueueWriteTexture(queue, destination, data, dataSize, dataLayout, in writeSize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) { // SpanOverloader thisApi.QueueWriteTexture(queue, destination, data, dataSize, in dataLayout.GetPinnableReference(), writeSize); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) { // SpanOverloader thisApi.QueueWriteTexture(queue, destination, data, dataSize, in dataLayout.GetPinnableReference(), in writeSize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged { // SpanOverloader thisApi.QueueWriteTexture(queue, destination, in data.GetPinnableReference(), dataSize, dataLayout, writeSize); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) where T0 : unmanaged + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) where T0 : unmanaged { // SpanOverloader thisApi.QueueWriteTexture(queue, destination, in data.GetPinnableReference(), dataSize, dataLayout, in writeSize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged { // SpanOverloader thisApi.QueueWriteTexture(queue, destination, in data.GetPinnableReference(), dataSize, in dataLayout.GetPinnableReference(), writeSize); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageCopyTexture* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) where T0 : unmanaged + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyTextureInfo* destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) where T0 : unmanaged { // SpanOverloader thisApi.QueueWriteTexture(queue, destination, in data.GetPinnableReference(), dataSize, in dataLayout.GetPinnableReference(), in writeSize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) { // SpanOverloader thisApi.QueueWriteTexture(queue, in destination.GetPinnableReference(), data, dataSize, dataLayout, writeSize); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) { // SpanOverloader thisApi.QueueWriteTexture(queue, in destination.GetPinnableReference(), data, dataSize, dataLayout, in writeSize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) { // SpanOverloader thisApi.QueueWriteTexture(queue, in destination.GetPinnableReference(), data, dataSize, in dataLayout.GetPinnableReference(), writeSize); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) { // SpanOverloader thisApi.QueueWriteTexture(queue, in destination.GetPinnableReference(), data, dataSize, in dataLayout.GetPinnableReference(), in writeSize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged { // SpanOverloader thisApi.QueueWriteTexture(queue, in destination.GetPinnableReference(), in data.GetPinnableReference(), dataSize, dataLayout, writeSize); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TextureDataLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) where T0 : unmanaged + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] TexelCopyBufferLayout* dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) where T0 : unmanaged { // SpanOverloader thisApi.QueueWriteTexture(queue, in destination.GetPinnableReference(), in data.GetPinnableReference(), dataSize, dataLayout, in writeSize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Extent3D* writeSize) where T0 : unmanaged { // SpanOverloader thisApi.QueueWriteTexture(queue, in destination.GetPinnableReference(), in data.GetPinnableReference(), dataSize, in dataLayout.GetPinnableReference(), writeSize); } /// To be documented. - [NativeName("Src", "Line 1693, Column 18 in webgpu.h")] - public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) where T0 : unmanaged + [NativeName("Src", "Line 6168, Column 18 in webgpu.h")] + public static unsafe void QueueWriteTexture(this WebGPU thisApi, Queue* queue, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan destination, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint dataSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dataLayout, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan writeSize) where T0 : unmanaged { // SpanOverloader thisApi.QueueWriteTexture(queue, in destination.GetPinnableReference(), in data.GetPinnableReference(), dataSize, in dataLayout.GetPinnableReference(), in writeSize.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1698, Column 18 in webgpu.h")] - public static unsafe void RenderBundleSetLabel(this WebGPU thisApi, RenderBundle* renderBundle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.RenderBundleSetLabel(renderBundle, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1707, Column 30 in webgpu.h")] + [NativeName("Src", "Line 6200, Column 30 in webgpu.h")] public static unsafe RenderBundle* RenderBundleEncoderFinish(this WebGPU thisApi, RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader @@ -777,23 +593,7 @@ public static unsafe void RenderBundleSetLabel(this WebGPU thisApi, RenderBundle } /// To be documented. - [NativeName("Src", "Line 1708, Column 18 in webgpu.h")] - public static unsafe void RenderBundleEncoderInsertDebugMarker(this WebGPU thisApi, RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerLabel) - { - // SpanOverloader - thisApi.RenderBundleEncoderInsertDebugMarker(renderBundleEncoder, in markerLabel.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1710, Column 18 in webgpu.h")] - public static unsafe void RenderBundleEncoderPushDebugGroup(this WebGPU thisApi, RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan groupLabel) - { - // SpanOverloader - thisApi.RenderBundleEncoderPushDebugGroup(renderBundleEncoder, in groupLabel.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1711, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6204, Column 18 in webgpu.h")] public static unsafe void RenderBundleEncoderSetBindGroup(this WebGPU thisApi, RenderBundleEncoder* renderBundleEncoder, uint groupIndex, BindGroup* group, nuint dynamicOffsetCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dynamicOffsets) { // SpanOverloader @@ -801,31 +601,7 @@ public static unsafe void RenderBundleEncoderSetBindGroup(this WebGPU thisApi, R } /// To be documented. - [NativeName("Src", "Line 1713, Column 18 in webgpu.h")] - public static unsafe void RenderBundleEncoderSetLabel(this WebGPU thisApi, RenderBundleEncoder* renderBundleEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.RenderBundleEncoderSetLabel(renderBundleEncoder, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1728, Column 18 in webgpu.h")] - public static unsafe void RenderPassEncoderInsertDebugMarker(this WebGPU thisApi, RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerLabel) - { - // SpanOverloader - thisApi.RenderPassEncoderInsertDebugMarker(renderPassEncoder, in markerLabel.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1730, Column 18 in webgpu.h")] - public static unsafe void RenderPassEncoderPushDebugGroup(this WebGPU thisApi, RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan groupLabel) - { - // SpanOverloader - thisApi.RenderPassEncoderPushDebugGroup(renderPassEncoder, in groupLabel.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1731, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6231, Column 18 in webgpu.h")] public static unsafe void RenderPassEncoderSetBindGroup(this WebGPU thisApi, RenderPassEncoder* renderPassEncoder, uint groupIndex, BindGroup* group, nuint dynamicOffsetCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dynamicOffsets) { // SpanOverloader @@ -833,7 +609,7 @@ public static unsafe void RenderPassEncoderSetBindGroup(this WebGPU thisApi, Ren } /// To be documented. - [NativeName("Src", "Line 1732, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6236, Column 18 in webgpu.h")] public static unsafe void RenderPassEncoderSetBlendConstant(this WebGPU thisApi, RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan color) { // SpanOverloader @@ -841,47 +617,7 @@ public static unsafe void RenderPassEncoderSetBlendConstant(this WebGPU thisApi, } /// To be documented. - [NativeName("Src", "Line 1734, Column 18 in webgpu.h")] - public static unsafe void RenderPassEncoderSetLabel(this WebGPU thisApi, RenderPassEncoder* renderPassEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.RenderPassEncoderSetLabel(renderPassEncoder, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1745, Column 18 in webgpu.h")] - public static unsafe void RenderPipelineSetLabel(this WebGPU thisApi, RenderPipeline* renderPipeline, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.RenderPipelineSetLabel(renderPipeline, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1750, Column 18 in webgpu.h")] - public static unsafe void SamplerSetLabel(this WebGPU thisApi, Sampler* sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.SamplerSetLabel(sampler, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1755, Column 18 in webgpu.h")] - public static unsafe void ShaderModuleGetCompilationInfo(this WebGPU thisApi, ShaderModule* shaderModule, PfnCompilationInfoCallback callback, Span userdata) where T0 : unmanaged - { - // SpanOverloader - thisApi.ShaderModuleGetCompilationInfo(shaderModule, callback, ref userdata.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1756, Column 18 in webgpu.h")] - public static unsafe void ShaderModuleSetLabel(this WebGPU thisApi, ShaderModule* shaderModule, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.ShaderModuleSetLabel(shaderModule, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1761, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6350, Column 18 in webgpu.h")] public static unsafe void SurfaceConfigure(this WebGPU thisApi, Surface* surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan config) { // SpanOverloader @@ -889,15 +625,15 @@ public static unsafe void SurfaceConfigure(this WebGPU thisApi, Surface* surface } /// To be documented. - [NativeName("Src", "Line 1762, Column 18 in webgpu.h")] - public static unsafe void SurfaceGetCapabilities(this WebGPU thisApi, Surface* surface, Adapter* adapter, Span capabilities) + [NativeName("Src", "Line 6366, Column 24 in webgpu.h")] + public static unsafe Status SurfaceGetCapabilities(this WebGPU thisApi, Surface* surface, Adapter* adapter, Span capabilities) { // SpanOverloader - thisApi.SurfaceGetCapabilities(surface, adapter, ref capabilities.GetPinnableReference()); + return thisApi.SurfaceGetCapabilities(surface, adapter, ref capabilities.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 1763, Column 18 in webgpu.h")] + [NativeName("Src", "Line 6376, Column 18 in webgpu.h")] public static unsafe void SurfaceGetCurrentTexture(this WebGPU thisApi, Surface* surface, Span surfaceTexture) { // SpanOverloader @@ -905,37 +641,13 @@ public static unsafe void SurfaceGetCurrentTexture(this WebGPU thisApi, Surface* } /// To be documented. - [NativeName("Src", "Line 1766, Column 18 in webgpu.h")] - public static unsafe void SurfaceSetLabel(this WebGPU thisApi, Surface* surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.SurfaceSetLabel(surface, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1775, Column 29 in webgpu.h")] + [NativeName("Src", "Line 6425, Column 29 in webgpu.h")] public static unsafe TextureView* TextureCreateView(this WebGPU thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan descriptor) { // SpanOverloader return thisApi.TextureCreateView(texture, in descriptor.GetPinnableReference()); } - /// To be documented. - [NativeName("Src", "Line 1785, Column 18 in webgpu.h")] - public static unsafe void TextureSetLabel(this WebGPU thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.TextureSetLabel(texture, in label.GetPinnableReference()); - } - - /// To be documented. - [NativeName("Src", "Line 1790, Column 18 in webgpu.h")] - public static unsafe void TextureViewSetLabel(this WebGPU thisApi, TextureView* textureView, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan label) - { - // SpanOverloader - thisApi.TextureViewSetLabel(textureView, in label.GetPinnableReference()); - } - } } diff --git a/src/Windowing/Silk.NET.SDL/Enums/AssertState.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/AssertState.gen.cs index 345f376bfa..462f0584d6 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/AssertState.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/AssertState.gen.cs @@ -9,7 +9,7 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_assert_L110_C9")] + [NativeName("AnonymousName", "__AnonymousEnum_SDL_assert_L112_C9")] [NativeName("Name", "SDL_AssertState")] public enum AssertState : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/AudioStatus.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/AudioStatus.gen.cs index ca07a5d92c..6fb44e3bdd 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/AudioStatus.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/AudioStatus.gen.cs @@ -9,7 +9,7 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_audio_L684_C9")] + [NativeName("AnonymousName", "__AnonymousEnum_SDL_audio_L681_C9")] [NativeName("Name", "SDL_AudioStatus")] public enum AudioStatus : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/BlendFactor.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/BlendFactor.gen.cs index 474520b17d..a5869e4fa2 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/BlendFactor.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/BlendFactor.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_blendmode_L77_C9")] [NativeName("Name", "SDL_BlendFactor")] public enum BlendFactor : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/BlendMode.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/BlendMode.gen.cs index e442f65ab1..9f063effa5 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/BlendMode.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/BlendMode.gen.cs @@ -10,7 +10,6 @@ namespace Silk.NET.SDL { [Flags] - [NativeName("AnonymousName", "__AnonymousEnum_SDL_blendmode_L40_C9")] [NativeName("Name", "SDL_BlendMode")] public enum BlendMode : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/BlendOperation.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/BlendOperation.gen.cs index 071304163b..4f7bf68057 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/BlendOperation.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/BlendOperation.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_blendmode_L65_C9")] [NativeName("Name", "SDL_BlendOperation")] public enum BlendOperation : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/DUMMYENUM.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/DUMMYENUM.gen.cs new file mode 100644 index 0000000000..22e93a4fb7 --- /dev/null +++ b/src/Windowing/Silk.NET.SDL/Enums/DUMMYENUM.gen.cs @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.SDL +{ + [NativeName("AnonymousName", "__AnonymousEnum_SDL_stdinc_L433_C9")] + [NativeName("Name", "SDL_DUMMY_ENUM")] + public enum DUMMYENUM : int + { + [NativeName("Name", "DUMMY_ENUM_VALUE")] + DummyEnumValue = 0x0, + } +} diff --git a/src/Windowing/Silk.NET.SDL/Enums/DisplayEventID.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/DisplayEventID.gen.cs index 46bd4f3759..da6e26a9be 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/DisplayEventID.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/DisplayEventID.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_video_L185_C9")] [NativeName("Name", "SDL_DisplayEventID")] public enum DisplayEventID : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/DisplayOrientation.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/DisplayOrientation.gen.cs index ede327e0ba..5c49a85e66 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/DisplayOrientation.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/DisplayOrientation.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_video_L197_C9")] [NativeName("Name", "SDL_DisplayOrientation")] public enum DisplayOrientation : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/EventType.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/EventType.gen.cs index f97b11d3b6..49e573cfe0 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/EventType.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/EventType.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_events_L55_C9")] [NativeName("Name", "SDL_EventType")] public enum EventType : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/Eventaction.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/Eventaction.gen.cs index aa6910cf40..d70b15c184 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/Eventaction.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/Eventaction.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_events_L699_C9")] [NativeName("Name", "SDL_eventaction")] public enum Eventaction : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/FlashOperation.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/FlashOperation.gen.cs index b3c1c2a537..df9d4750ab 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/FlashOperation.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/FlashOperation.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_video_L209_C9")] [NativeName("Name", "SDL_FlashOperation")] public enum FlashOperation : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/GLContextResetNotification.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/GLContextResetNotification.gen.cs index 72484fdde0..e4e84329cb 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/GLContextResetNotification.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/GLContextResetNotification.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_video_L277_C9")] [NativeName("Name", "SDL_GLContextResetNotification")] public enum GLContextResetNotification : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/GLattr.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/GLattr.gen.cs index 513219d264..62e0938ac9 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/GLattr.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/GLattr.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_video_L224_C9")] [NativeName("Name", "SDL_GLattr")] public enum GLattr : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/GLcontextFlag.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/GLcontextFlag.gen.cs index 007bbb9b91..4f940e2dce 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/GLcontextFlag.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/GLcontextFlag.gen.cs @@ -10,7 +10,6 @@ namespace Silk.NET.SDL { [Flags] - [NativeName("AnonymousName", "__AnonymousEnum_SDL_video_L263_C9")] [NativeName("Name", "SDL_GLcontextFlag")] public enum GLcontextFlag : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/GLcontextReleaseFlag.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/GLcontextReleaseFlag.gen.cs index 73408beccf..b523de8606 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/GLcontextReleaseFlag.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/GLcontextReleaseFlag.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_video_L271_C9")] [NativeName("Name", "SDL_GLcontextReleaseFlag")] public enum GLcontextReleaseFlag : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/GLprofile.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/GLprofile.gen.cs index c3eb7d6e62..ef11f21929 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/GLprofile.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/GLprofile.gen.cs @@ -10,7 +10,6 @@ namespace Silk.NET.SDL { [Flags] - [NativeName("AnonymousName", "__AnonymousEnum_SDL_video_L256_C9")] [NativeName("Name", "SDL_GLprofile")] public enum GLprofile : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/GameControllerAxis.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/GameControllerAxis.gen.cs index 5cab122956..8c855d1f11 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/GameControllerAxis.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/GameControllerAxis.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_gamecontroller_L620_C9")] [NativeName("Name", "SDL_GameControllerAxis")] public enum GameControllerAxis : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/GameControllerBindType.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/GameControllerBindType.gen.cs index e452960aa8..34b11acc3d 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/GameControllerBindType.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/GameControllerBindType.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_gamecontroller_L80_C9")] [NativeName("Name", "SDL_GameControllerBindType")] public enum GameControllerBindType : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/GameControllerButton.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/GameControllerButton.gen.cs index a41303fe56..29f4b614e4 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/GameControllerButton.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/GameControllerButton.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_gamecontroller_L730_C9")] [NativeName("Name", "SDL_GameControllerButton")] public enum GameControllerButton : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/GameControllerType.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/GameControllerType.gen.cs index 5dc6f2b547..266f1cb862 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/GameControllerType.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/GameControllerType.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_gamecontroller_L61_C9")] [NativeName("Name", "SDL_GameControllerType")] public enum GameControllerType : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/HintPriority.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/HintPriority.gen.cs index 70af279343..de9e19ca87 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/HintPriority.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/HintPriority.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_hints_L2718_C9")] [NativeName("Name", "SDL_HintPriority")] public enum HintPriority : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/HitTestResult.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/HitTestResult.gen.cs index 4f46d192d5..ba19abad8c 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/HitTestResult.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/HitTestResult.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_video_L1714_C9")] [NativeName("Name", "SDL_HitTestResult")] public enum HitTestResult : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/JoystickPowerLevel.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/JoystickPowerLevel.gen.cs index defb9c0463..171525de25 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/JoystickPowerLevel.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/JoystickPowerLevel.gen.cs @@ -9,7 +9,7 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_joystick_L102_C9")] + [NativeName("AnonymousName", "__AnonymousEnum_SDL_joystick_L112_C9")] [NativeName("Name", "SDL_JoystickPowerLevel")] public enum JoystickPowerLevel : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/JoystickType.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/JoystickType.gen.cs index a5a09ddc58..6ab0248038 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/JoystickType.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/JoystickType.gen.cs @@ -9,7 +9,7 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_joystick_L88_C9")] + [NativeName("AnonymousName", "__AnonymousEnum_SDL_joystick_L98_C9")] [NativeName("Name", "SDL_JoystickType")] public enum JoystickType : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/KeyCode.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/KeyCode.gen.cs index 71955c3f48..2817afd3d4 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/KeyCode.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/KeyCode.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_keycode_L50_C9")] [NativeName("Name", "SDL_KeyCode")] public enum KeyCode : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/Keymod.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/Keymod.gen.cs index 0900c6087a..bd22b1f46c 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/Keymod.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/Keymod.gen.cs @@ -10,7 +10,6 @@ namespace Silk.NET.SDL { [Flags] - [NativeName("AnonymousName", "__AnonymousEnum_SDL_keycode_L332_C9")] [NativeName("Name", "SDL_Keymod")] public enum Keymod : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/LogCategory.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/LogCategory.gen.cs index d0c5352ccb..5b3b148658 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/LogCategory.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/LogCategory.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_log_L64_C9")] [NativeName("Name", "SDL_LogCategory")] public enum LogCategory : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/LogPriority.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/LogPriority.gen.cs index 6b106992b4..c30f45a14f 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/LogPriority.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/LogPriority.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_log_L102_C9")] [NativeName("Name", "SDL_LogPriority")] public enum LogPriority : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/MessageBoxButtonFlags.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/MessageBoxButtonFlags.gen.cs index f070045a33..7758671b20 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/MessageBoxButtonFlags.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/MessageBoxButtonFlags.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_messagebox_L49_C9")] [NativeName("Name", "SDL_MessageBoxButtonFlags")] public enum MessageBoxButtonFlags : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/MessageBoxColorType.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/MessageBoxColorType.gen.cs index ad77540db5..a139099ee9 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/MessageBoxColorType.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/MessageBoxColorType.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_messagebox_L73_C9")] [NativeName("Name", "SDL_MessageBoxColorType")] public enum MessageBoxColorType : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/MessageBoxFlags.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/MessageBoxFlags.gen.cs index c046963fea..1b06312379 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/MessageBoxFlags.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/MessageBoxFlags.gen.cs @@ -10,7 +10,6 @@ namespace Silk.NET.SDL { [Flags] - [NativeName("AnonymousName", "__AnonymousEnum_SDL_messagebox_L37_C9")] [NativeName("Name", "SDL_MessageBoxFlags")] public enum MessageBoxFlags : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/MouseWheelDirection.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/MouseWheelDirection.gen.cs index b8fa1cd141..f1ab50788d 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/MouseWheelDirection.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/MouseWheelDirection.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_mouse_L66_C9")] [NativeName("Name", "SDL_MouseWheelDirection")] public enum MouseWheelDirection : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/PowerState.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/PowerState.gen.cs index 379e5349c8..3605c88399 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/PowerState.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/PowerState.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_power_L42_C9")] [NativeName("Name", "SDL_PowerState")] public enum PowerState : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/RendererFlags.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/RendererFlags.gen.cs index b3af2fc258..b1c6b584c5 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/RendererFlags.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/RendererFlags.gen.cs @@ -10,7 +10,6 @@ namespace Silk.NET.SDL { [Flags] - [NativeName("AnonymousName", "__AnonymousEnum_SDL_render_L64_C9")] [NativeName("Name", "SDL_RendererFlags")] public enum RendererFlags : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/RendererFlip.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/RendererFlip.gen.cs index 57cf35687f..d952f90f5f 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/RendererFlip.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/RendererFlip.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_render_L131_C9")] [NativeName("Name", "SDL_RendererFlip")] public enum RendererFlip : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/ScaleMode.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/ScaleMode.gen.cs index 4eaf1c255a..a7089ef564 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/ScaleMode.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/ScaleMode.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_render_L101_C9")] [NativeName("Name", "SDL_ScaleMode")] public enum ScaleMode : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/Scancode.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/Scancode.gen.cs index d6eeaff664..5a1fbce4b3 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/Scancode.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/Scancode.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_scancode_L43_C9")] [NativeName("Name", "SDL_Scancode")] public enum Scancode : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/SdlBool.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/SdlBool.gen.cs index a44e005f5b..90c031e9f5 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/SdlBool.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/SdlBool.gen.cs @@ -9,7 +9,7 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_stdinc_L180_C9")] + [NativeName("AnonymousName", "__AnonymousEnum_SDL_stdinc_L186_C9")] [NativeName("Name", "SDL_bool")] public enum SdlBool : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/SensorType.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/SensorType.gen.cs index a4460daeef..16898dbc2d 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/SensorType.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/SensorType.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_sensor_L69_C9")] [NativeName("Name", "SDL_SensorType")] public enum SensorType : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/SystemCursor.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/SystemCursor.gen.cs index 4c0ff3dcd1..9b0bd90b9d 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/SystemCursor.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/SystemCursor.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_mouse_L46_C9")] [NativeName("Name", "SDL_SystemCursor")] public enum SystemCursor : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/TextureAccess.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/TextureAccess.gen.cs index a6baf8392c..2d7b8f2e04 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/TextureAccess.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/TextureAccess.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_render_L111_C9")] [NativeName("Name", "SDL_TextureAccess")] public enum TextureAccess : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/TextureModulate.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/TextureModulate.gen.cs index 5538de04d1..5080f29323 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/TextureModulate.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/TextureModulate.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_render_L121_C9")] [NativeName("Name", "SDL_TextureModulate")] public enum TextureModulate : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/ThreadPriority.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/ThreadPriority.gen.cs index 786d7c652c..1dd0a29646 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/ThreadPriority.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/ThreadPriority.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_thread_L75_C9")] [NativeName("Name", "SDL_ThreadPriority")] public enum ThreadPriority : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/WinRTDeviceFamily.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/WinRTDeviceFamily.gen.cs index dad7d4f25c..6d6444676f 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/WinRTDeviceFamily.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/WinRTDeviceFamily.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_system_L499_C9")] [NativeName("Name", "SDL_WinRT_DeviceFamily")] public enum WinRTDeviceFamily : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/WinRTPath.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/WinRTPath.gen.cs index 5f2916d94b..4496535fb6 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/WinRTPath.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/WinRTPath.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_system_L475_C9")] [NativeName("Name", "SDL_WinRT_Path")] public enum WinRTPath : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/WindowEventID.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/WindowEventID.gen.cs index c170a20e35..b73e0929f5 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/WindowEventID.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/WindowEventID.gen.cs @@ -9,7 +9,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousEnum_SDL_video_L154_C9")] [NativeName("Name", "SDL_WindowEventID")] public enum WindowEventID : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/WindowFlags.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/WindowFlags.gen.cs index 9462fc8fad..2a9eb194c8 100644 --- a/src/Windowing/Silk.NET.SDL/Enums/WindowFlags.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Enums/WindowFlags.gen.cs @@ -10,7 +10,6 @@ namespace Silk.NET.SDL { [Flags] - [NativeName("AnonymousName", "__AnonymousEnum_SDL_video_L102_C9")] [NativeName("Name", "SDL_WindowFlags")] public enum WindowFlags : int { diff --git a/src/Windowing/Silk.NET.SDL/Enums/YUVCONVERSIONMODE.gen.cs b/src/Windowing/Silk.NET.SDL/Enums/YUVCONVERSIONMODE.gen.cs deleted file mode 100644 index 499ab85a8f..0000000000 --- a/src/Windowing/Silk.NET.SDL/Enums/YUVCONVERSIONMODE.gen.cs +++ /dev/null @@ -1,37 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using Silk.NET.Core.Attributes; - -#pragma warning disable 1591 - -namespace Silk.NET.SDL -{ - [NativeName("AnonymousName", "__AnonymousEnum_SDL_surface_L108_C9")] - [NativeName("Name", "SDL_YUV_CONVERSION_MODE")] - public enum YUVCONVERSIONMODE : int - { - [Obsolete("Deprecated in favour of \"Jpeg\"")] - [NativeName("Name", "SDL_YUV_CONVERSION_JPEG")] - YuvConversionJpeg = 0x0, - [Obsolete("Deprecated in favour of \"BT601\"")] - [NativeName("Name", "SDL_YUV_CONVERSION_BT601")] - YuvConversionBT601 = 0x1, - [Obsolete("Deprecated in favour of \"BT709\"")] - [NativeName("Name", "SDL_YUV_CONVERSION_BT709")] - YuvConversionBT709 = 0x2, - [Obsolete("Deprecated in favour of \"Automatic\"")] - [NativeName("Name", "SDL_YUV_CONVERSION_AUTOMATIC")] - YuvConversionAutomatic = 0x3, - [NativeName("Name", "SDL_YUV_CONVERSION_JPEG")] - Jpeg = 0x0, - [NativeName("Name", "SDL_YUV_CONVERSION_BT601")] - BT601 = 0x1, - [NativeName("Name", "SDL_YUV_CONVERSION_BT709")] - BT709 = 0x2, - [NativeName("Name", "SDL_YUV_CONVERSION_AUTOMATIC")] - Automatic = 0x3, - } -} diff --git a/src/Windowing/Silk.NET.SDL/Sdl.gen.cs b/src/Windowing/Silk.NET.SDL/Sdl.gen.cs index c7232ae471..4a2bb923db 100644 --- a/src/Windowing/Silk.NET.SDL/Sdl.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Sdl.gen.cs @@ -264,7 +264,7 @@ public unsafe partial class Sdl : NativeAPI public const string File = unchecked((string) "SDL.h"); [NativeName("Type", "int")] [NativeName("Name", "SDL_LINE")] - public const int Line = unchecked((int) 0x1B9); + public const int Line = unchecked((int) 0x1BA); [NativeName("Type", "int")] [NativeName("Name", "SDL_MUTEX_TIMEDOUT")] public const int MutexTimedout = unchecked((int) 0x1); @@ -488,9 +488,6 @@ public unsafe partial class Sdl : NativeAPI [NativeName("Name", "SDL_HINT_ENABLE_SCREEN_KEYBOARD")] public const string HintEnableScreenKeyboard = unchecked((string) "SDL_ENABLE_SCREEN_KEYBOARD"); [NativeName("Type", "")] - [NativeName("Name", "SDL_HINT_ENABLE_STEAM_CONTROLLERS")] - public const string HintEnableSteamControllers = unchecked((string) "SDL_ENABLE_STEAM_CONTROLLERS"); - [NativeName("Type", "")] [NativeName("Name", "SDL_HINT_EVENT_LOGGING")] public const string HintEventLogging = unchecked((string) "SDL_EVENT_LOGGING"); [NativeName("Type", "")] @@ -698,6 +695,9 @@ public unsafe partial class Sdl : NativeAPI [NativeName("Name", "SDL_HINT_JOYSTICK_DEVICE")] public const string HintJoystickDevice = unchecked((string) "SDL_JOYSTICK_DEVICE"); [NativeName("Type", "")] + [NativeName("Name", "SDL_HINT_JOYSTICK_HAPTIC_AXES")] + public const string HintJoystickHapticAxes = unchecked((string) "SDL_JOYSTICK_HAPTIC_AXES"); + [NativeName("Type", "")] [NativeName("Name", "SDL_HINT_LINUX_DIGITAL_HATS")] public const string HintLinuxDigitalHats = unchecked((string) "SDL_LINUX_DIGITAL_HATS"); [NativeName("Type", "")] @@ -1009,6 +1009,9 @@ public unsafe partial class Sdl : NativeAPI [NativeName("Type", "")] [NativeName("Name", "SDL_HINT_SHUTDOWN_DBUS_ON_QUIT")] public const string HintShutdownDbusOnQuit = unchecked((string) "SDL_SHUTDOWN_DBUS_ON_QUIT"); + [NativeName("Type", "")] + [NativeName("Name", "SDL_HINT_APPLE_RWFROMFILE_USE_RESOURCES")] + public const string HintAppleRwfromfileUseResources = unchecked((string) "SDL_APPLE_RWFROMFILE_USE_RESOURCES"); [NativeName("Type", "int")] [NativeName("Name", "SDL_MAX_LOG_MESSAGE")] public const int MaxLogMessage = unchecked((int) 0x1000); @@ -1023,7 +1026,7 @@ public unsafe partial class Sdl : NativeAPI public const int MajorVersion = unchecked((int) 0x2); [NativeName("Type", "int")] [NativeName("Name", "SDL_MINOR_VERSION")] - public const int MinorVersion = unchecked((int) 0x1E); + public const int MinorVersion = unchecked((int) 0x20); [NativeName("Type", "int")] [NativeName("Name", "SDL_PATCHLEVEL")] public const int Patchlevel = unchecked((int) 0x8); @@ -1067,4697 +1070,4697 @@ public unsafe partial class Sdl : NativeAPI public partial string GetPlatformS(); /// To be documented. - [NativeName("Src", "Line 444, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 457, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_malloc")] public unsafe partial void* Malloc(nuint size); /// To be documented. - [NativeName("Src", "Line 445, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 458, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_calloc")] public unsafe partial void* Calloc(nuint nmemb, nuint size); /// To be documented. - [NativeName("Src", "Line 446, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 459, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_realloc")] public unsafe partial void* Realloc(void* mem, nuint size); /// To be documented. - [NativeName("Src", "Line 446, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 459, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_realloc")] public unsafe partial void* Realloc(ref T0 mem, nuint size) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 447, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 460, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_free")] public unsafe partial void Free(void* mem); /// To be documented. - [NativeName("Src", "Line 447, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 460, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_free")] public partial void Free(ref T0 mem) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, ref PfnReallocFunc realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, ref PfnReallocFunc realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(PfnMallocFunc* malloc_func, ref PfnCallocFunc calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(PfnMallocFunc* malloc_func, ref PfnCallocFunc calloc_func, PfnReallocFunc* realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(PfnMallocFunc* malloc_func, ref PfnCallocFunc calloc_func, ref PfnReallocFunc realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(PfnMallocFunc* malloc_func, ref PfnCallocFunc calloc_func, ref PfnReallocFunc realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(ref PfnMallocFunc malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(ref PfnMallocFunc malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(ref PfnMallocFunc malloc_func, PfnCallocFunc* calloc_func, ref PfnReallocFunc realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(ref PfnMallocFunc malloc_func, PfnCallocFunc* calloc_func, ref PfnReallocFunc realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(ref PfnMallocFunc malloc_func, ref PfnCallocFunc calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(ref PfnMallocFunc malloc_func, ref PfnCallocFunc calloc_func, PfnReallocFunc* realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public unsafe partial void GetOriginalMemoryFunctions(ref PfnMallocFunc malloc_func, ref PfnCallocFunc calloc_func, ref PfnReallocFunc realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetOriginalMemoryFunctions")] public partial void GetOriginalMemoryFunctions(ref PfnMallocFunc malloc_func, ref PfnCallocFunc calloc_func, ref PfnReallocFunc realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, ref PfnReallocFunc realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, ref PfnReallocFunc realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(PfnMallocFunc* malloc_func, ref PfnCallocFunc calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(PfnMallocFunc* malloc_func, ref PfnCallocFunc calloc_func, PfnReallocFunc* realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(PfnMallocFunc* malloc_func, ref PfnCallocFunc calloc_func, ref PfnReallocFunc realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(PfnMallocFunc* malloc_func, ref PfnCallocFunc calloc_func, ref PfnReallocFunc realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(ref PfnMallocFunc malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(ref PfnMallocFunc malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(ref PfnMallocFunc malloc_func, PfnCallocFunc* calloc_func, ref PfnReallocFunc realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(ref PfnMallocFunc malloc_func, PfnCallocFunc* calloc_func, ref PfnReallocFunc realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(ref PfnMallocFunc malloc_func, ref PfnCallocFunc calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(ref PfnMallocFunc malloc_func, ref PfnCallocFunc calloc_func, PfnReallocFunc* realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public unsafe partial void GetMemoryFunctions(ref PfnMallocFunc malloc_func, ref PfnCallocFunc calloc_func, ref PfnReallocFunc realloc_func, PfnFreeFunc* free_func); /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetMemoryFunctions")] public partial void GetMemoryFunctions(ref PfnMallocFunc malloc_func, ref PfnCallocFunc calloc_func, ref PfnReallocFunc realloc_func, ref PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 479, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_SetMemoryFunctions")] public partial int SetMemoryFunctions(PfnMallocFunc malloc_func, PfnCallocFunc calloc_func, PfnReallocFunc realloc_func, PfnFreeFunc free_func); /// To be documented. - [NativeName("Src", "Line 489, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 502, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_GetNumAllocations")] public partial int GetNumAllocations(); /// To be documented. - [NativeName("Src", "Line 491, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 504, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_getenv")] public unsafe partial byte* Getenv([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name); /// To be documented. - [NativeName("Src", "Line 491, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 504, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_getenv")] public unsafe partial string GetenvS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name); /// To be documented. - [NativeName("Src", "Line 491, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 504, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_getenv")] public unsafe partial byte* Getenv([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name); /// To be documented. - [NativeName("Src", "Line 491, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 504, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_getenv")] public partial string GetenvS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name); /// To be documented. - [NativeName("Src", "Line 491, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 504, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_getenv")] public unsafe partial byte* Getenv([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name); /// To be documented. - [NativeName("Src", "Line 491, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 504, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_getenv")] public partial string GetenvS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name); /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_setenv")] public unsafe partial int Setenv([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value, int overwrite); /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_setenv")] public unsafe partial int Setenv([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte value, int overwrite); /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_setenv")] public unsafe partial int Setenv([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value, int overwrite); /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_setenv")] public unsafe partial int Setenv([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value, int overwrite); /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_setenv")] public partial int Setenv([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte value, int overwrite); /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_setenv")] public partial int Setenv([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value, int overwrite); /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_setenv")] public unsafe partial int Setenv([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value, int overwrite); /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_setenv")] public partial int Setenv([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte value, int overwrite); /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_setenv")] public partial int Setenv([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value, int overwrite); /// To be documented. - [NativeName("Src", "Line 494, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 508, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_qsort")] - public unsafe partial void Qsort(void* @base, nuint nmemb, nuint size, PfnVvVvI compare); + public unsafe partial void Qsort(void* @base, nuint nmemb, nuint size, PfnCompareCallback compare); /// To be documented. - [NativeName("Src", "Line 494, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 508, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_qsort")] - public partial void Qsort(ref T0 @base, nuint nmemb, nuint size, PfnVvVvI compare) where T0 : unmanaged; + public partial void Qsort(ref T0 @base, nuint nmemb, nuint size, PfnCompareCallback compare) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 495, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 509, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_bsearch")] - public unsafe partial void* Bsearch([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* @base, nuint nmemb, nuint size, PfnVvVvI compare); + public unsafe partial void* Bsearch([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* @base, nuint nmemb, nuint size, PfnCompareCallback compare); /// To be documented. - [NativeName("Src", "Line 495, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 509, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_bsearch")] - public unsafe partial void* Bsearch([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 @base, nuint nmemb, nuint size, PfnVvVvI compare) where T0 : unmanaged; + public unsafe partial void* Bsearch([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 @base, nuint nmemb, nuint size, PfnCompareCallback compare) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 495, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 509, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_bsearch")] - public unsafe partial void* Bsearch([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* @base, nuint nmemb, nuint size, PfnVvVvI compare) where T0 : unmanaged; + public unsafe partial void* Bsearch([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* @base, nuint nmemb, nuint size, PfnCompareCallback compare) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 495, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 509, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_bsearch")] - public unsafe partial void* Bsearch([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T1 @base, nuint nmemb, nuint size, PfnVvVvI compare) where T0 : unmanaged where T1 : unmanaged; + public unsafe partial void* Bsearch([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T1 @base, nuint nmemb, nuint size, PfnCompareCallback compare) where T0 : unmanaged where T1 : unmanaged; /// To be documented. - [NativeName("Src", "Line 497, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 511, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_abs")] public partial int Abs(int x); /// To be documented. - [NativeName("Src", "Line 504, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 518, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_isalpha")] public partial int Isalpha(int x); /// To be documented. - [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 519, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_isalnum")] public partial int Isalnum(int x); /// To be documented. - [NativeName("Src", "Line 506, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 520, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_isblank")] public partial int Isblank(int x); /// To be documented. - [NativeName("Src", "Line 507, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 521, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iscntrl")] public partial int Iscntrl(int x); /// To be documented. - [NativeName("Src", "Line 508, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 522, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_isdigit")] public partial int Isdigit(int x); /// To be documented. - [NativeName("Src", "Line 509, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 523, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_isxdigit")] public partial int Isxdigit(int x); /// To be documented. - [NativeName("Src", "Line 510, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 524, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ispunct")] public partial int Ispunct(int x); /// To be documented. - [NativeName("Src", "Line 511, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 525, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_isspace")] public partial int Isspace(int x); /// To be documented. - [NativeName("Src", "Line 512, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_isupper")] public partial int Isupper(int x); /// To be documented. - [NativeName("Src", "Line 513, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 527, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_islower")] public partial int Islower(int x); /// To be documented. - [NativeName("Src", "Line 514, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 528, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_isprint")] public partial int Isprint(int x); /// To be documented. - [NativeName("Src", "Line 515, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 529, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_isgraph")] public partial int Isgraph(int x); /// To be documented. - [NativeName("Src", "Line 516, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 530, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_toupper")] public partial int Toupper(int x); /// To be documented. - [NativeName("Src", "Line 517, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 531, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_tolower")] public partial int Tolower(int x); /// To be documented. - [NativeName("Src", "Line 519, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 533, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_crc16")] public unsafe partial ushort Crc16(ushort crc, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint len); /// To be documented. - [NativeName("Src", "Line 519, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 533, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_crc16")] public partial ushort Crc16(ushort crc, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 520, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 534, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_crc32")] public unsafe partial uint Crc32(uint crc, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, nuint len); /// To be documented. - [NativeName("Src", "Line 520, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 534, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_crc32")] public partial uint Crc32(uint crc, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, nuint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 522, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 536, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memset")] public unsafe partial void* Memset(void* dst, int c, nuint len); /// To be documented. - [NativeName("Src", "Line 522, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 536, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memset")] public unsafe partial void* Memset(ref T0 dst, int c, nuint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 562, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 577, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memcpy")] public unsafe partial void* Memcpy(void* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, nuint len); /// To be documented. - [NativeName("Src", "Line 562, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 577, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memcpy")] public unsafe partial void* Memcpy(void* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 src, nuint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 562, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 577, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memcpy")] public unsafe partial void* Memcpy(ref T0 dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, nuint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 562, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 577, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memcpy")] public unsafe partial void* Memcpy(ref T0 dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T1 src, nuint len) where T0 : unmanaged where T1 : unmanaged; /// To be documented. - [NativeName("Src", "Line 564, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 579, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memmove")] public unsafe partial void* Memmove(void* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, nuint len); /// To be documented. - [NativeName("Src", "Line 564, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 579, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memmove")] public unsafe partial void* Memmove(void* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 src, nuint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 564, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 579, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memmove")] public unsafe partial void* Memmove(ref T0 dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, nuint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 564, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 579, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memmove")] public unsafe partial void* Memmove(ref T0 dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T1 src, nuint len) where T0 : unmanaged where T1 : unmanaged; /// To be documented. - [NativeName("Src", "Line 565, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 580, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memcmp")] public unsafe partial int Memcmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* s2, nuint len); /// To be documented. - [NativeName("Src", "Line 565, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 580, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memcmp")] public unsafe partial int Memcmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 s2, nuint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 565, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 580, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memcmp")] public unsafe partial int Memcmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* s2, nuint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 565, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 580, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_memcmp")] public partial int Memcmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T1 s2, nuint len) where T0 : unmanaged where T1 : unmanaged; /// To be documented. - [NativeName("Src", "Line 567, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 582, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslen")] public unsafe partial nuint Wcslen([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wstr); /// To be documented. - [NativeName("Src", "Line 567, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 582, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslen")] public partial nuint Wcslen([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char wstr); /// To be documented. - [NativeName("Src", "Line 567, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 582, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslen")] public partial nuint Wcslen([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wstr); /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcpy")] public unsafe partial nuint Wcslcpy(char* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcpy")] public unsafe partial nuint Wcslcpy(char* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcpy")] public unsafe partial nuint Wcslcpy(char* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcpy")] public unsafe partial nuint Wcslcpy(ref char dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcpy")] public partial nuint Wcslcpy(ref char dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcpy")] public partial nuint Wcslcpy(ref char dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcpy")] public unsafe partial nuint Wcslcpy([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcpy")] public partial nuint Wcslcpy([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcpy")] public partial nuint Wcslcpy([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcat")] public unsafe partial nuint Wcslcat(char* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcat")] public unsafe partial nuint Wcslcat(char* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcat")] public unsafe partial nuint Wcslcat(char* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcat")] public unsafe partial nuint Wcslcat(ref char dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcat")] public partial nuint Wcslcat(ref char dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcat")] public partial nuint Wcslcat(ref char dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcat")] public unsafe partial nuint Wcslcat([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcat")] public partial nuint Wcslcat([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcslcat")] public partial nuint Wcslcat([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 570, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 585, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsdup")] public unsafe partial char* Wcsdup([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wstr); /// To be documented. - [NativeName("Src", "Line 570, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 585, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsdup")] public unsafe partial string WcsdupS([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wstr); /// To be documented. - [NativeName("Src", "Line 570, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 585, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsdup")] public unsafe partial char* Wcsdup([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char wstr); /// To be documented. - [NativeName("Src", "Line 570, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 585, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsdup")] public partial string WcsdupS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char wstr); /// To be documented. - [NativeName("Src", "Line 570, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 585, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsdup")] public unsafe partial char* Wcsdup([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wstr); /// To be documented. - [NativeName("Src", "Line 570, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 585, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsdup")] public partial string WcsdupS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wstr); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial char* Wcsstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial string WcsstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial char* Wcsstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial string WcsstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial char* Wcsstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial string WcsstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial char* Wcsstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial string WcsstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial char* Wcsstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsstr")] public partial string WcsstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial char* Wcsstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsstr")] public partial string WcsstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial char* Wcsstr([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial string WcsstrS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial char* Wcsstr([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsstr")] public partial string WcsstrS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsstr")] public unsafe partial char* Wcsstr([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_wcsstr")] public partial string WcsstrS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscmp")] public unsafe partial int Wcscmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2); /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscmp")] public unsafe partial int Wcscmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2); /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscmp")] public unsafe partial int Wcscmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscmp")] public unsafe partial int Wcscmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2); /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscmp")] public partial int Wcscmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2); /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscmp")] public partial int Wcscmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscmp")] public unsafe partial int Wcscmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2); /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscmp")] public partial int Wcscmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2); /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscmp")] public partial int Wcscmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncmp")] public unsafe partial int Wcsncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncmp")] public unsafe partial int Wcsncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncmp")] public unsafe partial int Wcsncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncmp")] public unsafe partial int Wcsncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncmp")] public partial int Wcsncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncmp")] public partial int Wcsncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncmp")] public unsafe partial int Wcsncmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncmp")] public partial int Wcsncmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncmp")] public partial int Wcsncmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscasecmp")] public unsafe partial int Wcscasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2); /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscasecmp")] public unsafe partial int Wcscasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2); /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscasecmp")] public unsafe partial int Wcscasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscasecmp")] public unsafe partial int Wcscasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2); /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscasecmp")] public partial int Wcscasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2); /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscasecmp")] public partial int Wcscasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscasecmp")] public unsafe partial int Wcscasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2); /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscasecmp")] public partial int Wcscasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2); /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcscasecmp")] public partial int Wcscasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncasecmp")] public unsafe partial int Wcsncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2, nuint len); /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncasecmp")] public unsafe partial int Wcsncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2, nuint len); /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncasecmp")] public unsafe partial int Wcsncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint len); /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncasecmp")] public unsafe partial int Wcsncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2, nuint len); /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncasecmp")] public partial int Wcsncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2, nuint len); /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncasecmp")] public partial int Wcsncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint len); /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncasecmp")] public unsafe partial int Wcsncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2, nuint len); /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncasecmp")] public partial int Wcsncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char str2, nuint len); /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_wcsncasecmp")] public partial int Wcsncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint len); /// To be documented. - [NativeName("Src", "Line 578, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 593, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlen")] public unsafe partial nuint Strlen([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str); /// To be documented. - [NativeName("Src", "Line 578, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 593, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlen")] public partial nuint Strlen([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str); /// To be documented. - [NativeName("Src", "Line 578, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 593, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlen")] public partial nuint Strlen([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcpy")] public unsafe partial nuint Strlcpy(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcpy")] public unsafe partial nuint Strlcpy(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcpy")] public unsafe partial nuint Strlcpy(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcpy")] public unsafe partial nuint Strlcpy(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcpy")] public partial nuint Strlcpy(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcpy")] public partial nuint Strlcpy(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcpy")] public unsafe partial nuint Strlcpy([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcpy")] public partial nuint Strlcpy([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcpy")] public partial nuint Strlcpy([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlcpy")] public unsafe partial nuint Utf8strlcpy(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint dst_bytes); /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlcpy")] public unsafe partial nuint Utf8strlcpy(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, nuint dst_bytes); /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlcpy")] public unsafe partial nuint Utf8strlcpy(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint dst_bytes); /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlcpy")] public unsafe partial nuint Utf8strlcpy(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint dst_bytes); /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlcpy")] public partial nuint Utf8strlcpy(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, nuint dst_bytes); /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlcpy")] public partial nuint Utf8strlcpy(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint dst_bytes); /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlcpy")] public unsafe partial nuint Utf8strlcpy([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint dst_bytes); /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlcpy")] public partial nuint Utf8strlcpy([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, nuint dst_bytes); /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlcpy")] public partial nuint Utf8strlcpy([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint dst_bytes); /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcat")] public unsafe partial nuint Strlcat(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcat")] public unsafe partial nuint Strlcat(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcat")] public unsafe partial nuint Strlcat(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcat")] public unsafe partial nuint Strlcat(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcat")] public partial nuint Strlcat(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcat")] public partial nuint Strlcat(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcat")] public unsafe partial nuint Strlcat([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcat")] public partial nuint Strlcat([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlcat")] public partial nuint Strlcat([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 582, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strdup")] public unsafe partial byte* Strdup([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str); /// To be documented. - [NativeName("Src", "Line 582, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strdup")] public unsafe partial string StrdupS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str); /// To be documented. - [NativeName("Src", "Line 582, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strdup")] public unsafe partial byte* Strdup([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str); /// To be documented. - [NativeName("Src", "Line 582, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strdup")] public partial string StrdupS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str); /// To be documented. - [NativeName("Src", "Line 582, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strdup")] public unsafe partial byte* Strdup([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 582, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strdup")] public partial string StrdupS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 583, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strrev")] public unsafe partial byte* Strrev(byte* str); /// To be documented. - [NativeName("Src", "Line 583, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strrev")] public unsafe partial string StrrevS(byte* str); /// To be documented. - [NativeName("Src", "Line 583, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strrev")] public unsafe partial byte* Strrev(ref byte str); /// To be documented. - [NativeName("Src", "Line 583, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strrev")] public partial string StrrevS(ref byte str); /// To be documented. - [NativeName("Src", "Line 583, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strrev")] public unsafe partial byte* Strrev([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 583, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strrev")] public partial string StrrevS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 584, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strupr")] public unsafe partial byte* Strupr(byte* str); /// To be documented. - [NativeName("Src", "Line 584, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strupr")] public unsafe partial string StruprS(byte* str); /// To be documented. - [NativeName("Src", "Line 584, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strupr")] public unsafe partial byte* Strupr(ref byte str); /// To be documented. - [NativeName("Src", "Line 584, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strupr")] public partial string StruprS(ref byte str); /// To be documented. - [NativeName("Src", "Line 584, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strupr")] public unsafe partial byte* Strupr([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 584, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strupr")] public partial string StruprS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 585, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 600, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlwr")] public unsafe partial byte* Strlwr(byte* str); /// To be documented. - [NativeName("Src", "Line 585, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 600, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strlwr")] public unsafe partial string StrlwrS(byte* str); /// To be documented. - [NativeName("Src", "Line 585, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 600, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlwr")] public unsafe partial byte* Strlwr(ref byte str); /// To be documented. - [NativeName("Src", "Line 585, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 600, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strlwr")] public partial string StrlwrS(ref byte str); /// To be documented. - [NativeName("Src", "Line 585, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 600, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strlwr")] public unsafe partial byte* Strlwr([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 585, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 600, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strlwr")] public partial string StrlwrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 586, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 601, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strchr")] public unsafe partial byte* Strchr([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, int c); /// To be documented. - [NativeName("Src", "Line 586, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 601, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strchr")] public unsafe partial string StrchrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, int c); /// To be documented. - [NativeName("Src", "Line 586, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 601, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strchr")] public unsafe partial byte* Strchr([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, int c); /// To be documented. - [NativeName("Src", "Line 586, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 601, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strchr")] public partial string StrchrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, int c); /// To be documented. - [NativeName("Src", "Line 586, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 601, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strchr")] public unsafe partial byte* Strchr([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int c); /// To be documented. - [NativeName("Src", "Line 586, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 601, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strchr")] public partial string StrchrS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int c); /// To be documented. - [NativeName("Src", "Line 587, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 602, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strrchr")] public unsafe partial byte* Strrchr([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, int c); /// To be documented. - [NativeName("Src", "Line 587, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 602, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strrchr")] public unsafe partial string StrrchrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, int c); /// To be documented. - [NativeName("Src", "Line 587, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 602, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strrchr")] public unsafe partial byte* Strrchr([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, int c); /// To be documented. - [NativeName("Src", "Line 587, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 602, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strrchr")] public partial string StrrchrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, int c); /// To be documented. - [NativeName("Src", "Line 587, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 602, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strrchr")] public unsafe partial byte* Strrchr([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int c); /// To be documented. - [NativeName("Src", "Line 587, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 602, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strrchr")] public partial string StrrchrS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int c); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial byte* Strstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial string StrstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial byte* Strstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial string StrstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial byte* Strstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial string StrstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial byte* Strstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial string StrstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial byte* Strstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strstr")] public partial string StrstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial byte* Strstr([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strstr")] public partial string StrstrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial byte* Strstr([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial string StrstrS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial byte* Strstr([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strstr")] public partial string StrstrS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strstr")] public unsafe partial byte* Strstr([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strstr")] public partial string StrstrS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial byte* Strcasestr([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial string StrcasestrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial byte* Strcasestr([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial string StrcasestrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial byte* Strcasestr([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial string StrcasestrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial byte* Strcasestr([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial string StrcasestrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial byte* Strcasestr([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strcasestr")] public partial string StrcasestrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial byte* Strcasestr([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strcasestr")] public partial string StrcasestrS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial byte* Strcasestr([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial string StrcasestrS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial byte* Strcasestr([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strcasestr")] public partial string StrcasestrS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasestr")] public unsafe partial byte* Strcasestr([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strcasestr")] public partial string StrcasestrS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, byte** saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial byte* Strtokr([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_strtokr")] public unsafe partial string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, ref byte* saveptr); /// To be documented. - [NativeName("Src", "Line 591, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlen")] public unsafe partial nuint Utf8strlen([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str); /// To be documented. - [NativeName("Src", "Line 591, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlen")] public partial nuint Utf8strlen([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str); /// To be documented. - [NativeName("Src", "Line 591, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strlen")] public partial nuint Utf8strlen([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 592, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strnlen")] public unsafe partial nuint Utf8strnlen([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, nuint bytes); /// To be documented. - [NativeName("Src", "Line 592, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strnlen")] public partial nuint Utf8strnlen([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, nuint bytes); /// To be documented. - [NativeName("Src", "Line 592, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_utf8strnlen")] public partial nuint Utf8strnlen([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, nuint bytes); /// To be documented. - [NativeName("Src", "Line 594, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 609, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_itoa")] public unsafe partial byte* Itoa(int value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 594, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 609, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_itoa")] public unsafe partial string ItoaS(int value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 594, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 609, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_itoa")] public unsafe partial byte* Itoa(int value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 594, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 609, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_itoa")] public partial string ItoaS(int value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 594, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 609, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_itoa")] public unsafe partial byte* Itoa(int value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 594, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 609, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_itoa")] public partial string ItoaS(int value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 595, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 610, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_uitoa")] public unsafe partial byte* Uitoa(uint value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 595, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 610, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_uitoa")] public unsafe partial string UitoaS(uint value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 595, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 610, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_uitoa")] public unsafe partial byte* Uitoa(uint value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 595, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 610, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_uitoa")] public partial string UitoaS(uint value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 595, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 610, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_uitoa")] public unsafe partial byte* Uitoa(uint value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 595, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 610, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_uitoa")] public partial string UitoaS(uint value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 596, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 611, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ltoa")] public unsafe partial byte* Ltoa(int value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 596, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 611, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_ltoa")] public unsafe partial string LtoaS(int value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 596, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 611, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ltoa")] public unsafe partial byte* Ltoa(int value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 596, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 611, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_ltoa")] public partial string LtoaS(int value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 596, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 611, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ltoa")] public unsafe partial byte* Ltoa(int value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 596, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 611, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_ltoa")] public partial string LtoaS(int value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 612, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ultoa")] public unsafe partial byte* Ultoa(uint value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 612, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_ultoa")] public unsafe partial string UltoaS(uint value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 612, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ultoa")] public unsafe partial byte* Ultoa(uint value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 612, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_ultoa")] public partial string UltoaS(uint value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 612, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ultoa")] public unsafe partial byte* Ultoa(uint value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 612, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_ultoa")] public partial string UltoaS(uint value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 613, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_lltoa")] public unsafe partial byte* Lltoa(long value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 613, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_lltoa")] public unsafe partial string LltoaS(long value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 613, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_lltoa")] public unsafe partial byte* Lltoa(long value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 613, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_lltoa")] public partial string LltoaS(long value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 613, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_lltoa")] public unsafe partial byte* Lltoa(long value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 613, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_lltoa")] public partial string LltoaS(long value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 614, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ulltoa")] public unsafe partial byte* Ulltoa(ulong value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 614, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_ulltoa")] public unsafe partial string UlltoaS(ulong value, byte* str, int radix); /// To be documented. - [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 614, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ulltoa")] public unsafe partial byte* Ulltoa(ulong value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 614, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_ulltoa")] public partial string UlltoaS(ulong value, ref byte str, int radix); /// To be documented. - [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 614, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ulltoa")] public unsafe partial byte* Ulltoa(ulong value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 614, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_ulltoa")] public partial string UlltoaS(ulong value, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, int radix); /// To be documented. - [NativeName("Src", "Line 601, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_atoi")] public unsafe partial int Atoi([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str); /// To be documented. - [NativeName("Src", "Line 601, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_atoi")] public partial int Atoi([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str); /// To be documented. - [NativeName("Src", "Line 601, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_atoi")] public partial int Atoi([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 602, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 617, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_atof")] public unsafe partial double Atof([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str); /// To be documented. - [NativeName("Src", "Line 602, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 617, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_atof")] public partial double Atof([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str); /// To be documented. - [NativeName("Src", "Line 602, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 617, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_atof")] public partial double Atof([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 603, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 618, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtol")] public unsafe partial int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 603, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 618, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtol")] public unsafe partial int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 603, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 618, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtol")] public unsafe partial int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 603, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 618, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtol")] public unsafe partial int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 603, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 618, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtol")] public unsafe partial int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 603, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 618, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtol")] public unsafe partial int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 604, Column 39 in SDL_stdinc.h")] + [NativeName("Src", "Line 619, Column 39 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoul")] public unsafe partial uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 604, Column 39 in SDL_stdinc.h")] + [NativeName("Src", "Line 619, Column 39 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoul")] public unsafe partial uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 604, Column 39 in SDL_stdinc.h")] + [NativeName("Src", "Line 619, Column 39 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoul")] public unsafe partial uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 604, Column 39 in SDL_stdinc.h")] + [NativeName("Src", "Line 619, Column 39 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoul")] public unsafe partial uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 604, Column 39 in SDL_stdinc.h")] + [NativeName("Src", "Line 619, Column 39 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoul")] public unsafe partial uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 604, Column 39 in SDL_stdinc.h")] + [NativeName("Src", "Line 619, Column 39 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoul")] public unsafe partial uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 605, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 620, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoll")] public unsafe partial long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 605, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 620, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoll")] public unsafe partial long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 605, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 620, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoll")] public unsafe partial long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 605, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 620, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoll")] public unsafe partial long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 605, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 620, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoll")] public unsafe partial long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 605, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 620, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoll")] public unsafe partial long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 621, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoull")] public unsafe partial ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 621, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoull")] public unsafe partial ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 621, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoull")] public unsafe partial ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 621, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoull")] public unsafe partial ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 621, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoull")] public unsafe partial ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, byte** endp, int @base); /// To be documented. - [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 621, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtoull")] public unsafe partial ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, ref byte* endp, int @base); /// To be documented. - [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 622, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtod")] public unsafe partial double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, byte** endp); /// To be documented. - [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 622, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtod")] public unsafe partial double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, ref byte* endp); /// To be documented. - [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 622, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtod")] public unsafe partial double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, byte** endp); /// To be documented. - [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 622, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtod")] public unsafe partial double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, ref byte* endp); /// To be documented. - [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 622, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtod")] public unsafe partial double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, byte** endp); /// To be documented. - [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 622, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strtod")] public unsafe partial double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, ref byte* endp); /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcmp")] public unsafe partial int Strcmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2); /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcmp")] public unsafe partial int Strcmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2); /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcmp")] public unsafe partial int Strcmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcmp")] public unsafe partial int Strcmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2); /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcmp")] public partial int Strcmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2); /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcmp")] public partial int Strcmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcmp")] public unsafe partial int Strcmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2); /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcmp")] public partial int Strcmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2); /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcmp")] public partial int Strcmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncmp")] public unsafe partial int Strncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncmp")] public unsafe partial int Strncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncmp")] public unsafe partial int Strncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncmp")] public unsafe partial int Strncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncmp")] public partial int Strncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncmp")] public partial int Strncmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncmp")] public unsafe partial int Strncmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncmp")] public partial int Strncmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncmp")] public partial int Strncmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasecmp")] public unsafe partial int Strcasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2); /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasecmp")] public unsafe partial int Strcasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2); /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasecmp")] public unsafe partial int Strcasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasecmp")] public unsafe partial int Strcasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2); /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasecmp")] public partial int Strcasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2); /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasecmp")] public partial int Strcasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasecmp")] public unsafe partial int Strcasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2); /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasecmp")] public partial int Strcasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2); /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strcasecmp")] public partial int Strcasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2); /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncasecmp")] public unsafe partial int Strncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2, nuint len); /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncasecmp")] public unsafe partial int Strncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2, nuint len); /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncasecmp")] public unsafe partial int Strncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint len); /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncasecmp")] public unsafe partial int Strncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2, nuint len); /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncasecmp")] public partial int Strncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2, nuint len); /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncasecmp")] public partial int Strncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint len); /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncasecmp")] public unsafe partial int Strncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2, nuint len); /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncasecmp")] public partial int Strncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str2, nuint len); /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_strncasecmp")] public partial int Strncasecmp([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint len); /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sscanf")] public unsafe partial int Sscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt); /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sscanf")] public unsafe partial int Sscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt); /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sscanf")] public unsafe partial int Sscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt); /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sscanf")] public unsafe partial int Sscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt); /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sscanf")] public partial int Sscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt); /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sscanf")] public partial int Sscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt); /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sscanf")] public unsafe partial int Sscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt); /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sscanf")] public partial int Sscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt); /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sscanf")] public partial int Sscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public unsafe partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsscanf")] public partial int Vsscanf([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_snprintf")] public unsafe partial int Snprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt); /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_snprintf")] public unsafe partial int Snprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt); /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_snprintf")] public unsafe partial int Snprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt); /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_snprintf")] public unsafe partial int Snprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt); /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_snprintf")] public partial int Snprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt); /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_snprintf")] public partial int Snprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt); /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_snprintf")] public unsafe partial int Snprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt); /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_snprintf")] public partial int Snprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt); /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_snprintf")] public partial int Snprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public partial int Vsnprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public partial int Vsnprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public partial int Vsnprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public partial int Vsnprintf(ref byte text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public partial int Vsnprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public partial int Vsnprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public unsafe partial int Vsnprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public partial int Vsnprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vsnprintf")] public partial int Vsnprintf([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 618, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 633, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_asprintf")] public unsafe partial int Asprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt); /// To be documented. - [NativeName("Src", "Line 618, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 633, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_asprintf")] public unsafe partial int Asprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt); /// To be documented. - [NativeName("Src", "Line 618, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 633, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_asprintf")] public unsafe partial int Asprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt); /// To be documented. - [NativeName("Src", "Line 618, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 633, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_asprintf")] public unsafe partial int Asprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt); /// To be documented. - [NativeName("Src", "Line 618, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 633, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_asprintf")] public unsafe partial int Asprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt); /// To be documented. - [NativeName("Src", "Line 618, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 633, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_asprintf")] public unsafe partial int Asprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, byte* ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, ref byte ap); /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_vasprintf")] public unsafe partial int Vasprintf(ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 641, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 656, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_acos")] public partial double Acos(double x); /// To be documented. - [NativeName("Src", "Line 642, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 657, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_acosf")] public partial float Acosf(float x); /// To be documented. - [NativeName("Src", "Line 643, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 658, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_asin")] public partial double Asin(double x); /// To be documented. - [NativeName("Src", "Line 644, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 659, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_asinf")] public partial float Asinf(float x); /// To be documented. - [NativeName("Src", "Line 645, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 660, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_atan")] public partial double Atan(double x); /// To be documented. - [NativeName("Src", "Line 646, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 661, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_atanf")] public partial float Atanf(float x); /// To be documented. - [NativeName("Src", "Line 647, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 662, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_atan2")] public partial double Atan2(double y, double x); /// To be documented. - [NativeName("Src", "Line 648, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 663, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_atan2f")] public partial float Atan2f(float y, float x); /// To be documented. - [NativeName("Src", "Line 649, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 664, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ceil")] public partial double Ceil(double x); /// To be documented. - [NativeName("Src", "Line 650, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 665, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_ceilf")] public partial float Ceilf(float x); /// To be documented. - [NativeName("Src", "Line 651, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 666, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_copysign")] public partial double Copysign(double x, double y); /// To be documented. - [NativeName("Src", "Line 652, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 667, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_copysignf")] public partial float Copysignf(float x, float y); /// To be documented. - [NativeName("Src", "Line 653, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 668, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_cos")] public partial double Cos(double x); /// To be documented. - [NativeName("Src", "Line 654, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 669, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_cosf")] public partial float Cosf(float x); /// To be documented. - [NativeName("Src", "Line 655, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 670, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_exp")] public partial double Exp(double x); /// To be documented. - [NativeName("Src", "Line 656, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 671, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_expf")] public partial float Expf(float x); /// To be documented. - [NativeName("Src", "Line 657, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 672, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_fabs")] public partial double Fabs(double x); /// To be documented. - [NativeName("Src", "Line 658, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 673, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_fabsf")] public partial float Fabsf(float x); /// To be documented. - [NativeName("Src", "Line 659, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 674, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_floor")] public partial double Floor(double x); /// To be documented. - [NativeName("Src", "Line 660, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 675, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_floorf")] public partial float Floorf(float x); /// To be documented. - [NativeName("Src", "Line 661, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 676, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_trunc")] public partial double Trunc(double x); /// To be documented. - [NativeName("Src", "Line 662, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 677, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_truncf")] public partial float Truncf(float x); /// To be documented. - [NativeName("Src", "Line 663, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 678, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_fmod")] public partial double Fmod(double x, double y); /// To be documented. - [NativeName("Src", "Line 664, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 679, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_fmodf")] public partial float Fmodf(float x, float y); /// To be documented. - [NativeName("Src", "Line 665, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 680, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_log")] public partial double Log(double x); /// To be documented. - [NativeName("Src", "Line 666, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 681, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_logf")] public partial float Logf(float x); /// To be documented. - [NativeName("Src", "Line 667, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 682, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_log10")] public partial double Log10(double x); /// To be documented. - [NativeName("Src", "Line 668, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 683, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_log10f")] public partial float Log10f(float x); /// To be documented. - [NativeName("Src", "Line 669, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 684, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_pow")] public partial double Pow(double x, double y); /// To be documented. - [NativeName("Src", "Line 670, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 685, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_powf")] public partial float Powf(float x, float y); /// To be documented. - [NativeName("Src", "Line 671, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 686, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_round")] public partial double Round(double x); /// To be documented. - [NativeName("Src", "Line 672, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 687, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_roundf")] public partial float Roundf(float x); /// To be documented. - [NativeName("Src", "Line 673, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 688, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_lround")] public partial int Lround(double x); /// To be documented. - [NativeName("Src", "Line 674, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 689, Column 30 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_lroundf")] public partial int Lroundf(float x); /// To be documented. - [NativeName("Src", "Line 675, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 690, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_scalbn")] public partial double Scalbn(double x, int n); /// To be documented. - [NativeName("Src", "Line 676, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 691, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_scalbnf")] public partial float Scalbnf(float x, int n); /// To be documented. - [NativeName("Src", "Line 677, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 692, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sin")] public partial double Sin(double x); /// To be documented. - [NativeName("Src", "Line 678, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 693, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sinf")] public partial float Sinf(float x); /// To be documented. - [NativeName("Src", "Line 679, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 694, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sqrt")] public partial double Sqrt(double x); /// To be documented. - [NativeName("Src", "Line 680, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 695, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_sqrtf")] public partial float Sqrtf(float x); /// To be documented. - [NativeName("Src", "Line 681, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 696, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_tan")] public partial double Tan(double x); /// To be documented. - [NativeName("Src", "Line 682, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 697, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_tanf")] public partial float Tanf(float x); /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_open")] public unsafe partial Icon* IconvOpen([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode); /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_open")] public unsafe partial Icon* IconvOpen([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode); /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_open")] public unsafe partial Icon* IconvOpen([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode); /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_open")] public unsafe partial Icon* IconvOpen([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode); /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_open")] public unsafe partial Icon* IconvOpen([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode); /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_open")] public unsafe partial Icon* IconvOpen([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode); /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_open")] public unsafe partial Icon* IconvOpen([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode); /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_open")] public unsafe partial Icon* IconvOpen([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode); /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_open")] public unsafe partial Icon* IconvOpen([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode); /// To be documented. - [NativeName("Src", "Line 694, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 709, Column 29 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_close")] public unsafe partial int IconvClose(Icon* cd); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, nuint* inbytesleft, byte** outbuf, nuint* outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, nuint* inbytesleft, byte** outbuf, ref nuint outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, nuint* inbytesleft, ref byte* outbuf, nuint* outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, nuint* inbytesleft, ref byte* outbuf, ref nuint outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, ref nuint inbytesleft, byte** outbuf, nuint* outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, ref nuint inbytesleft, byte** outbuf, ref nuint outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, ref nuint inbytesleft, ref byte* outbuf, nuint* outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, ref nuint inbytesleft, ref byte* outbuf, ref nuint outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, nuint* inbytesleft, byte** outbuf, nuint* outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, nuint* inbytesleft, byte** outbuf, ref nuint outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, nuint* inbytesleft, ref byte* outbuf, nuint* outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, nuint* inbytesleft, ref byte* outbuf, ref nuint outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, ref nuint inbytesleft, byte** outbuf, nuint* outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, ref nuint inbytesleft, byte** outbuf, ref nuint outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, ref nuint inbytesleft, ref byte* outbuf, nuint* outbytesleft); /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv")] public unsafe partial nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, ref nuint inbytesleft, ref byte* outbuf, ref nuint outbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [NativeApi(EntryPoint = "SDL_iconv_string")] public unsafe partial byte* IconvString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_iconv_string")] public partial string IconvStringS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft); /// To be documented. - [NativeName("Src", "Line 379, Column 37 in SDL_pixels.h")] + [NativeName("Src", "Line 403, Column 37 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetPixelFormatName")] public unsafe partial byte* GetPixelFormatName(uint format); /// To be documented. - [NativeName("Src", "Line 379, Column 37 in SDL_pixels.h")] + [NativeName("Src", "Line 403, Column 37 in SDL_pixels.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetPixelFormatName")] public partial string GetPixelFormatNameS(uint format); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, uint* Rmask, uint* Gmask, uint* Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, uint* Rmask, uint* Gmask, uint* Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, uint* Rmask, uint* Gmask, ref uint Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, uint* Rmask, uint* Gmask, ref uint Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, uint* Rmask, ref uint Gmask, uint* Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, uint* Rmask, ref uint Gmask, uint* Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, uint* Rmask, ref uint Gmask, ref uint Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, uint* Rmask, ref uint Gmask, ref uint Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, ref uint Rmask, uint* Gmask, uint* Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, ref uint Rmask, uint* Gmask, uint* Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, ref uint Rmask, uint* Gmask, ref uint Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, ref uint Rmask, uint* Gmask, ref uint Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, ref uint Rmask, ref uint Gmask, uint* Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, ref uint Rmask, ref uint Gmask, uint* Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, ref uint Rmask, ref uint Gmask, ref uint Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, int* bpp, ref uint Rmask, ref uint Gmask, ref uint Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, uint* Rmask, uint* Gmask, uint* Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, uint* Rmask, uint* Gmask, uint* Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, uint* Rmask, uint* Gmask, ref uint Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, uint* Rmask, uint* Gmask, ref uint Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, uint* Rmask, ref uint Gmask, uint* Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, uint* Rmask, ref uint Gmask, uint* Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, uint* Rmask, ref uint Gmask, ref uint Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, uint* Rmask, ref uint Gmask, ref uint Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, ref uint Rmask, uint* Gmask, uint* Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, ref uint Rmask, uint* Gmask, uint* Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, ref uint Rmask, uint* Gmask, ref uint Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, ref uint Rmask, uint* Gmask, ref uint Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, ref uint Rmask, ref uint Gmask, uint* Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, ref uint Rmask, ref uint Gmask, uint* Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public unsafe partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, ref uint Rmask, ref uint Gmask, ref uint Bmask, uint* Amask); /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_PixelFormatEnumToMasks")] public partial SdlBool PixelFormatEnumToMasks(uint format, ref int bpp, ref uint Rmask, ref uint Gmask, ref uint Bmask, ref uint Amask); /// To be documented. - [NativeName("Src", "Line 421, Column 32 in SDL_pixels.h")] + [NativeName("Src", "Line 445, Column 32 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_MasksToPixelFormatEnum")] public partial uint MasksToPixelFormatEnum(int bpp, uint Rmask, uint Gmask, uint Bmask, uint Amask); /// To be documented. - [NativeName("Src", "Line 442, Column 43 in SDL_pixels.h")] + [NativeName("Src", "Line 466, Column 43 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_AllocFormat")] public unsafe partial PixelFormat* AllocFormat(uint pixel_format); /// To be documented. - [NativeName("Src", "Line 453, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 477, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_FreeFormat")] public unsafe partial void FreeFormat(PixelFormat* format); /// To be documented. - [NativeName("Src", "Line 453, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 477, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_FreeFormat")] public partial void FreeFormat(ref PixelFormat format); /// To be documented. - [NativeName("Src", "Line 469, Column 38 in SDL_pixels.h")] + [NativeName("Src", "Line 493, Column 38 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_AllocPalette")] public unsafe partial Palette* AllocPalette(int ncolors); /// To be documented. - [NativeName("Src", "Line 484, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 508, Column 29 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_SetPixelFormatPalette")] public unsafe partial int SetPixelFormatPalette(PixelFormat* format, Palette* palette); /// To be documented. - [NativeName("Src", "Line 484, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 508, Column 29 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_SetPixelFormatPalette")] public unsafe partial int SetPixelFormatPalette(PixelFormat* format, ref Palette palette); /// To be documented. - [NativeName("Src", "Line 484, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 508, Column 29 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_SetPixelFormatPalette")] public unsafe partial int SetPixelFormatPalette(ref PixelFormat format, Palette* palette); /// To be documented. - [NativeName("Src", "Line 484, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 508, Column 29 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_SetPixelFormatPalette")] public partial int SetPixelFormatPalette(ref PixelFormat format, ref Palette palette); /// To be documented. - [NativeName("Src", "Line 502, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_SetPaletteColors")] public unsafe partial int SetPaletteColors(Palette* palette, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* colors, int firstcolor, int ncolors); /// To be documented. - [NativeName("Src", "Line 502, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_SetPaletteColors")] public unsafe partial int SetPaletteColors(Palette* palette, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Color colors, int firstcolor, int ncolors); /// To be documented. - [NativeName("Src", "Line 502, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_SetPaletteColors")] public unsafe partial int SetPaletteColors(ref Palette palette, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* colors, int firstcolor, int ncolors); /// To be documented. - [NativeName("Src", "Line 502, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_SetPaletteColors")] public partial int SetPaletteColors(ref Palette palette, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Color colors, int firstcolor, int ncolors); /// To be documented. - [NativeName("Src", "Line 515, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 539, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_FreePalette")] public unsafe partial void FreePalette(Palette* palette); /// To be documented. - [NativeName("Src", "Line 515, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 539, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_FreePalette")] public partial void FreePalette(ref Palette palette); /// To be documented. - [NativeName("Src", "Line 547, Column 32 in SDL_pixels.h")] + [NativeName("Src", "Line 571, Column 32 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_MapRGB")] public unsafe partial uint MapRGB([Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte r, byte g, byte b); /// To be documented. - [NativeName("Src", "Line 547, Column 32 in SDL_pixels.h")] + [NativeName("Src", "Line 571, Column 32 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_MapRGB")] public partial uint MapRGB([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte r, byte g, byte b); /// To be documented. - [NativeName("Src", "Line 582, Column 32 in SDL_pixels.h")] + [NativeName("Src", "Line 606, Column 32 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_MapRGBA")] public unsafe partial uint MapRGBA([Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte r, byte g, byte b, byte a); /// To be documented. - [NativeName("Src", "Line 582, Column 32 in SDL_pixels.h")] + [NativeName("Src", "Line 606, Column 32 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_MapRGBA")] public partial uint MapRGBA([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte r, byte g, byte b, byte a); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public unsafe partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGB")] public partial void GetRGB(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public unsafe partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_GetRGBA")] public partial void GetRGBA(uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 651, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 675, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_CalculateGammaRamp")] public unsafe partial void CalculateGammaRamp(float gamma, ushort* ramp); /// To be documented. - [NativeName("Src", "Line 651, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 675, Column 30 in SDL_pixels.h")] [NativeApi(EntryPoint = "SDL_CalculateGammaRamp")] public partial void CalculateGammaRamp(float gamma, ref ushort ramp); @@ -6431,7 +6434,7 @@ public unsafe partial class Sdl : NativeAPI public partial SdlBool IntersectFRectAndLine([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FRect rect, ref float X1, ref float Y1, ref float X2, ref float Y2); /// To be documented. - [NativeName("Src", "Line 183, Column 39 in SDL_blendmode.h")] + [NativeName("Src", "Line 184, Column 39 in SDL_blendmode.h")] [NativeApi(EntryPoint = "SDL_ComposeCustomBlendMode")] public partial BlendMode ComposeCustomBlendMode(BlendFactor srcColorFactor, BlendFactor dstColorFactor, BlendOperation colorOperation, BlendFactor srcAlphaFactor, BlendFactor dstAlphaFactor, BlendOperation alphaOperation); @@ -6446,2226 +6449,2226 @@ public unsafe partial class Sdl : NativeAPI public unsafe partial Surface* CreateRGBSurfaceWithFormat(uint flags, int width, int height, int depth, uint format); /// To be documented. - [NativeName("Src", "Line 219, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 220, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_CreateRGBSurfaceFrom")] public unsafe partial Surface* CreateRGBSurfaceFrom(void* pixels, int width, int height, int depth, int pitch, uint Rmask, uint Gmask, uint Bmask, uint Amask); /// To be documented. - [NativeName("Src", "Line 219, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 220, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_CreateRGBSurfaceFrom")] public unsafe partial Surface* CreateRGBSurfaceFrom(ref T0 pixels, int width, int height, int depth, int pitch, uint Rmask, uint Gmask, uint Bmask, uint Amask) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 257, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 258, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_CreateRGBSurfaceWithFormatFrom")] public unsafe partial Surface* CreateRGBSurfaceWithFormatFrom(void* pixels, int width, int height, int depth, int pitch, uint format); /// To be documented. - [NativeName("Src", "Line 257, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 258, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_CreateRGBSurfaceWithFormatFrom")] public unsafe partial Surface* CreateRGBSurfaceWithFormatFrom(ref T0 pixels, int width, int height, int depth, int pitch, uint format) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 274, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 275, Column 30 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_FreeSurface")] public unsafe partial void FreeSurface(Surface* surface); /// To be documented. - [NativeName("Src", "Line 274, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 275, Column 30 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_FreeSurface")] public partial void FreeSurface(ref Surface surface); /// To be documented. - [NativeName("Src", "Line 288, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 289, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfacePalette")] public unsafe partial int SetSurfacePalette(Surface* surface, Palette* palette); /// To be documented. - [NativeName("Src", "Line 288, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 289, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfacePalette")] public unsafe partial int SetSurfacePalette(Surface* surface, ref Palette palette); /// To be documented. - [NativeName("Src", "Line 288, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 289, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfacePalette")] public unsafe partial int SetSurfacePalette(ref Surface surface, Palette* palette); /// To be documented. - [NativeName("Src", "Line 288, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 289, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfacePalette")] public partial int SetSurfacePalette(ref Surface surface, ref Palette palette); /// To be documented. - [NativeName("Src", "Line 312, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 313, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LockSurface")] public unsafe partial int LockSurface(Surface* surface); /// To be documented. - [NativeName("Src", "Line 312, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 313, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LockSurface")] public partial int LockSurface(ref Surface surface); /// To be documented. - [NativeName("Src", "Line 323, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 324, Column 30 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UnlockSurface")] public unsafe partial void UnlockSurface(Surface* surface); /// To be documented. - [NativeName("Src", "Line 323, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 324, Column 30 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UnlockSurface")] public partial void UnlockSurface(ref Surface surface); /// To be documented. - [NativeName("Src", "Line 347, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 348, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LoadBMP_RW")] public unsafe partial Surface* LoadBMPRW(RWops* src, int freesrc); /// To be documented. - [NativeName("Src", "Line 347, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 348, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LoadBMP_RW")] public unsafe partial Surface* LoadBMPRW(ref RWops src, int freesrc); /// To be documented. - [NativeName("Src", "Line 377, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 378, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SaveBMP_RW")] public unsafe partial int SaveBMPRW(Surface* surface, RWops* dst, int freedst); /// To be documented. - [NativeName("Src", "Line 377, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 378, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SaveBMP_RW")] public unsafe partial int SaveBMPRW(Surface* surface, ref RWops dst, int freedst); /// To be documented. - [NativeName("Src", "Line 377, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 378, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SaveBMP_RW")] public unsafe partial int SaveBMPRW(ref Surface surface, RWops* dst, int freedst); /// To be documented. - [NativeName("Src", "Line 377, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 378, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SaveBMP_RW")] public partial int SaveBMPRW(ref Surface surface, ref RWops dst, int freedst); /// To be documented. - [NativeName("Src", "Line 405, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 406, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfaceRLE")] public unsafe partial int SetSurfaceRLE(Surface* surface, int flag); /// To be documented. - [NativeName("Src", "Line 405, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 406, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfaceRLE")] public partial int SetSurfaceRLE(ref Surface surface, int flag); /// To be documented. - [NativeName("Src", "Line 420, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_HasSurfaceRLE")] public unsafe partial SdlBool HasSurfaceRLE(Surface* surface); /// To be documented. - [NativeName("Src", "Line 420, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_HasSurfaceRLE")] public partial SdlBool HasSurfaceRLE(ref Surface surface); /// To be documented. - [NativeName("Src", "Line 446, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 447, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetColorKey")] public unsafe partial int SetColorKey(Surface* surface, int flag, uint key); /// To be documented. - [NativeName("Src", "Line 446, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 447, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetColorKey")] public partial int SetColorKey(ref Surface surface, int flag, uint key); /// To be documented. - [NativeName("Src", "Line 462, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 463, Column 34 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_HasColorKey")] public unsafe partial SdlBool HasColorKey(Surface* surface); /// To be documented. - [NativeName("Src", "Line 462, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 463, Column 34 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_HasColorKey")] public partial SdlBool HasColorKey(ref Surface surface); /// To be documented. - [NativeName("Src", "Line 482, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 483, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetColorKey")] public unsafe partial int GetColorKey(Surface* surface, uint* key); /// To be documented. - [NativeName("Src", "Line 482, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 483, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetColorKey")] public unsafe partial int GetColorKey(Surface* surface, ref uint key); /// To be documented. - [NativeName("Src", "Line 482, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 483, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetColorKey")] public unsafe partial int GetColorKey(ref Surface surface, uint* key); /// To be documented. - [NativeName("Src", "Line 482, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 483, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetColorKey")] public partial int GetColorKey(ref Surface surface, ref uint key); /// To be documented. - [NativeName("Src", "Line 506, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 507, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfaceColorMod")] public unsafe partial int SetSurfaceColorMod(Surface* surface, byte r, byte g, byte b); /// To be documented. - [NativeName("Src", "Line 506, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 507, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfaceColorMod")] public partial int SetSurfaceColorMod(ref Surface surface, byte r, byte g, byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, byte* r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, byte* r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, byte* r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, byte* r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, ref byte r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, ref byte r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, ref byte r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, ref byte r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, byte* r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, byte* r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, byte* r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, byte* r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, ref byte r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, ref byte r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, ref byte r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public partial int GetSurfaceColorMod(ref Surface surface, ref byte r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public partial int GetSurfaceColorMod(ref Surface surface, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public partial int GetSurfaceColorMod(ref Surface surface, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public partial int GetSurfaceColorMod(ref Surface surface, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public partial int GetSurfaceColorMod(ref Surface surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public partial int GetSurfaceColorMod(ref Surface surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public unsafe partial int GetSurfaceColorMod(ref Surface surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public partial int GetSurfaceColorMod(ref Surface surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceColorMod")] public partial int GetSurfaceColorMod(ref Surface surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 547, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 548, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfaceAlphaMod")] public unsafe partial int SetSurfaceAlphaMod(Surface* surface, byte alpha); /// To be documented. - [NativeName("Src", "Line 547, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 548, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfaceAlphaMod")] public partial int SetSurfaceAlphaMod(ref Surface surface, byte alpha); /// To be documented. - [NativeName("Src", "Line 563, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 564, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceAlphaMod")] public unsafe partial int GetSurfaceAlphaMod(Surface* surface, byte* alpha); /// To be documented. - [NativeName("Src", "Line 563, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 564, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceAlphaMod")] public unsafe partial int GetSurfaceAlphaMod(Surface* surface, ref byte alpha); /// To be documented. - [NativeName("Src", "Line 563, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 564, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceAlphaMod")] public unsafe partial int GetSurfaceAlphaMod(Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string alpha); /// To be documented. - [NativeName("Src", "Line 563, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 564, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceAlphaMod")] public unsafe partial int GetSurfaceAlphaMod(ref Surface surface, byte* alpha); /// To be documented. - [NativeName("Src", "Line 563, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 564, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceAlphaMod")] public partial int GetSurfaceAlphaMod(ref Surface surface, ref byte alpha); /// To be documented. - [NativeName("Src", "Line 563, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 564, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceAlphaMod")] public partial int GetSurfaceAlphaMod(ref Surface surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string alpha); /// To be documented. - [NativeName("Src", "Line 582, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 583, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfaceBlendMode")] public unsafe partial int SetSurfaceBlendMode(Surface* surface, BlendMode blendMode); /// To be documented. - [NativeName("Src", "Line 582, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 583, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetSurfaceBlendMode")] public partial int SetSurfaceBlendMode(ref Surface surface, BlendMode blendMode); /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceBlendMode")] public unsafe partial int GetSurfaceBlendMode(Surface* surface, BlendMode* blendMode); /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceBlendMode")] public unsafe partial int GetSurfaceBlendMode(Surface* surface, ref BlendMode blendMode); /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceBlendMode")] public unsafe partial int GetSurfaceBlendMode(ref Surface surface, BlendMode* blendMode); /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetSurfaceBlendMode")] public partial int GetSurfaceBlendMode(ref Surface surface, ref BlendMode blendMode); /// To be documented. - [NativeName("Src", "Line 620, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 621, Column 34 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetClipRect")] public unsafe partial SdlBool SetClipRect(Surface* surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 620, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 621, Column 34 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetClipRect")] public unsafe partial SdlBool SetClipRect(Surface* surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 620, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 621, Column 34 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetClipRect")] public unsafe partial SdlBool SetClipRect(ref Surface surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 620, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 621, Column 34 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetClipRect")] public partial SdlBool SetClipRect(ref Surface surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 639, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 640, Column 30 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetClipRect")] public unsafe partial void GetClipRect(Surface* surface, Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 639, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 640, Column 30 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetClipRect")] public unsafe partial void GetClipRect(Surface* surface, ref Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 639, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 640, Column 30 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetClipRect")] public unsafe partial void GetClipRect(ref Surface surface, Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 639, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 640, Column 30 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetClipRect")] public partial void GetClipRect(ref Surface surface, ref Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 651, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 652, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_DuplicateSurface")] public unsafe partial Surface* DuplicateSurface(Surface* surface); /// To be documented. - [NativeName("Src", "Line 651, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 652, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_DuplicateSurface")] public unsafe partial Surface* DuplicateSurface(ref Surface surface); /// To be documented. - [NativeName("Src", "Line 675, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 676, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_ConvertSurface")] public unsafe partial Surface* ConvertSurface(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* fmt, uint flags); /// To be documented. - [NativeName("Src", "Line 675, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 676, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_ConvertSurface")] public unsafe partial Surface* ConvertSurface(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat fmt, uint flags); /// To be documented. - [NativeName("Src", "Line 675, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 676, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_ConvertSurface")] public unsafe partial Surface* ConvertSurface(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* fmt, uint flags); /// To be documented. - [NativeName("Src", "Line 675, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 676, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_ConvertSurface")] public unsafe partial Surface* ConvertSurface(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly PixelFormat fmt, uint flags); /// To be documented. - [NativeName("Src", "Line 700, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 701, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_ConvertSurfaceFormat")] public unsafe partial Surface* ConvertSurfaceFormat(Surface* src, uint pixel_format, uint flags); /// To be documented. - [NativeName("Src", "Line 700, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 701, Column 38 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_ConvertSurfaceFormat")] public unsafe partial Surface* ConvertSurfaceFormat(ref Surface src, uint pixel_format, uint flags); /// To be documented. - [NativeName("Src", "Line 719, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 720, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_ConvertPixels")] public unsafe partial int ConvertPixels(int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, int src_pitch, uint dst_format, void* dst, int dst_pitch); /// To be documented. - [NativeName("Src", "Line 719, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 720, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_ConvertPixels")] public unsafe partial int ConvertPixels(int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, int src_pitch, uint dst_format, ref T0 dst, int dst_pitch) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 719, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 720, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_ConvertPixels")] public unsafe partial int ConvertPixels(int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 src, int src_pitch, uint dst_format, void* dst, int dst_pitch) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 719, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 720, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_ConvertPixels")] public partial int ConvertPixels(int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 src, int src_pitch, uint dst_format, ref T1 dst, int dst_pitch) where T0 : unmanaged where T1 : unmanaged; /// To be documented. - [NativeName("Src", "Line 745, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 746, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_PremultiplyAlpha")] public unsafe partial int PremultiplyAlpha(int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, int src_pitch, uint dst_format, void* dst, int dst_pitch); /// To be documented. - [NativeName("Src", "Line 745, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 746, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_PremultiplyAlpha")] public unsafe partial int PremultiplyAlpha(int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, int src_pitch, uint dst_format, ref T0 dst, int dst_pitch) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 745, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 746, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_PremultiplyAlpha")] public unsafe partial int PremultiplyAlpha(int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 src, int src_pitch, uint dst_format, void* dst, int dst_pitch) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 745, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 746, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_PremultiplyAlpha")] public partial int PremultiplyAlpha(int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 src, int src_pitch, uint dst_format, ref T1 dst, int dst_pitch) where T0 : unmanaged where T1 : unmanaged; /// To be documented. - [NativeName("Src", "Line 774, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 775, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_FillRect")] public unsafe partial int FillRect(Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, uint color); /// To be documented. - [NativeName("Src", "Line 774, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 775, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_FillRect")] public unsafe partial int FillRect(Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, uint color); /// To be documented. - [NativeName("Src", "Line 774, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 775, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_FillRect")] public unsafe partial int FillRect(ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, uint color); /// To be documented. - [NativeName("Src", "Line 774, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 775, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_FillRect")] public partial int FillRect(ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, uint color); /// To be documented. - [NativeName("Src", "Line 800, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 801, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_FillRects")] public unsafe partial int FillRects(Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rects, int count, uint color); /// To be documented. - [NativeName("Src", "Line 800, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 801, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_FillRects")] public unsafe partial int FillRects(Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rects, int count, uint color); /// To be documented. - [NativeName("Src", "Line 800, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 801, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_FillRects")] public unsafe partial int FillRects(ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rects, int count, uint color); /// To be documented. - [NativeName("Src", "Line 800, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 801, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_FillRects")] public partial int FillRects(ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rects, int count, uint color); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public unsafe partial int UpperBlit(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlit")] public partial int UpperBlit(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(Surface* src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(Surface* src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(Surface* src, Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(Surface* src, Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(Surface* src, ref Silk.NET.Maths.Rectangle srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(Surface* src, ref Silk.NET.Maths.Rectangle srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(Surface* src, ref Silk.NET.Maths.Rectangle srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(Surface* src, ref Silk.NET.Maths.Rectangle srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(ref Surface src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(ref Surface src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(ref Surface src, Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(ref Surface src, Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(ref Surface src, ref Silk.NET.Maths.Rectangle srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(ref Surface src, ref Silk.NET.Maths.Rectangle srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public unsafe partial int LowerBlit(ref Surface src, ref Silk.NET.Maths.Rectangle srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlit")] public partial int LowerBlit(ref Surface src, ref Silk.NET.Maths.Rectangle srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public unsafe partial int SoftStretch(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretch")] public partial int SoftStretch(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public unsafe partial int SoftStretchLinear(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SoftStretchLinear")] public partial int SoftStretchLinear(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public unsafe partial int UpperBlitScaled(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_UpperBlitScaled")] public partial int UpperBlitScaled(ref Surface src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(Surface* src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(Surface* src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(Surface* src, Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(Surface* src, Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(Surface* src, ref Silk.NET.Maths.Rectangle srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(Surface* src, ref Silk.NET.Maths.Rectangle srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(Surface* src, ref Silk.NET.Maths.Rectangle srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(Surface* src, ref Silk.NET.Maths.Rectangle srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(ref Surface src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(ref Surface src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(ref Surface src, Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(ref Surface src, Silk.NET.Maths.Rectangle* srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(ref Surface src, ref Silk.NET.Maths.Rectangle srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(ref Surface src, ref Silk.NET.Maths.Rectangle srcrect, Surface* dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public unsafe partial int LowerBlitScaled(ref Surface src, ref Silk.NET.Maths.Rectangle srcrect, ref Surface dst, Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_LowerBlitScaled")] public partial int LowerBlitScaled(ref Surface src, ref Silk.NET.Maths.Rectangle srcrect, ref Surface dst, ref Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 972, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 976, Column 30 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_SetYUVConversionMode")] - public partial void SetYUVConversionMode(YUVCONVERSIONMODE mode); + public partial void SetYUVConversionMode(YuvConversionMode mode); /// To be documented. - [NativeName("Src", "Line 979, Column 49 in SDL_surface.h")] + [NativeName("Src", "Line 983, Column 49 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetYUVConversionMode")] - public partial YUVCONVERSIONMODE GetYUVConversionMode(); + public partial YuvConversionMode GetYUVConversionMode(); /// To be documented. - [NativeName("Src", "Line 987, Column 49 in SDL_surface.h")] + [NativeName("Src", "Line 991, Column 49 in SDL_surface.h")] [NativeApi(EntryPoint = "SDL_GetYUVConversionModeForResolution")] - public partial YUVCONVERSIONMODE GetYUVConversionModeForResolution(int width, int height); + public partial YuvConversionMode GetYUVConversionModeForResolution(int width, int height); /// To be documented. - [NativeName("Src", "Line 295, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 327, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetNumVideoDrivers")] public partial int GetNumVideoDrivers(); /// To be documented. - [NativeName("Src", "Line 310, Column 37 in SDL_video.h")] + [NativeName("Src", "Line 342, Column 37 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetVideoDriver")] public unsafe partial byte* GetVideoDriver(int index); /// To be documented. - [NativeName("Src", "Line 310, Column 37 in SDL_video.h")] + [NativeName("Src", "Line 342, Column 37 in SDL_video.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetVideoDriver")] public partial string GetVideoDriverS(int index); /// To be documented. - [NativeName("Src", "Line 341, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 373, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_VideoInit")] public unsafe partial int VideoInit([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* driver_name); /// To be documented. - [NativeName("Src", "Line 341, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 373, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_VideoInit")] public partial int VideoInit([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte driver_name); /// To be documented. - [NativeName("Src", "Line 341, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 373, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_VideoInit")] public partial int VideoInit([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string driver_name); /// To be documented. - [NativeName("Src", "Line 352, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 384, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_VideoQuit")] public partial void VideoQuit(); /// To be documented. - [NativeName("Src", "Line 365, Column 37 in SDL_video.h")] + [NativeName("Src", "Line 397, Column 37 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetCurrentVideoDriver")] public unsafe partial byte* GetCurrentVideoDriver(); /// To be documented. - [NativeName("Src", "Line 365, Column 37 in SDL_video.h")] + [NativeName("Src", "Line 397, Column 37 in SDL_video.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetCurrentVideoDriver")] public partial string GetCurrentVideoDriverS(); /// To be documented. - [NativeName("Src", "Line 377, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 409, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetNumVideoDisplays")] public partial int GetNumVideoDisplays(); /// To be documented. - [NativeName("Src", "Line 391, Column 38 in SDL_video.h")] + [NativeName("Src", "Line 423, Column 38 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayName")] public unsafe partial byte* GetDisplayName(int displayIndex); /// To be documented. - [NativeName("Src", "Line 391, Column 38 in SDL_video.h")] + [NativeName("Src", "Line 423, Column 38 in SDL_video.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetDisplayName")] public partial string GetDisplayNameS(int displayIndex); /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 439, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayBounds")] public unsafe partial int GetDisplayBounds(int displayIndex, Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 439, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayBounds")] public partial int GetDisplayBounds(int displayIndex, ref Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 438, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 470, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayUsableBounds")] public unsafe partial int GetDisplayUsableBounds(int displayIndex, Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 438, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 470, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayUsableBounds")] public partial int GetDisplayUsableBounds(int displayIndex, ref Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayDPI")] public unsafe partial int GetDisplayDPI(int displayIndex, float* ddpi, float* hdpi, float* vdpi); /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayDPI")] public unsafe partial int GetDisplayDPI(int displayIndex, float* ddpi, float* hdpi, ref float vdpi); /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayDPI")] public unsafe partial int GetDisplayDPI(int displayIndex, float* ddpi, ref float hdpi, float* vdpi); /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayDPI")] public unsafe partial int GetDisplayDPI(int displayIndex, float* ddpi, ref float hdpi, ref float vdpi); /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayDPI")] public unsafe partial int GetDisplayDPI(int displayIndex, ref float ddpi, float* hdpi, float* vdpi); /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayDPI")] public unsafe partial int GetDisplayDPI(int displayIndex, ref float ddpi, float* hdpi, ref float vdpi); /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayDPI")] public unsafe partial int GetDisplayDPI(int displayIndex, ref float ddpi, ref float hdpi, float* vdpi); /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayDPI")] public partial int GetDisplayDPI(int displayIndex, ref float ddpi, ref float hdpi, ref float vdpi); /// To be documented. - [NativeName("Src", "Line 486, Column 48 in SDL_video.h")] + [NativeName("Src", "Line 518, Column 48 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayOrientation")] public partial DisplayOrientation GetDisplayOrientation(int displayIndex); /// To be documented. - [NativeName("Src", "Line 503, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 535, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetNumDisplayModes")] public partial int GetNumDisplayModes(int displayIndex); /// To be documented. - [NativeName("Src", "Line 527, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 559, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayMode")] public unsafe partial int GetDisplayMode(int displayIndex, int modeIndex, DisplayMode* mode); /// To be documented. - [NativeName("Src", "Line 527, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 559, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDisplayMode")] public partial int GetDisplayMode(int displayIndex, int modeIndex, ref DisplayMode mode); /// To be documented. - [NativeName("Src", "Line 550, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 582, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDesktopDisplayMode")] public unsafe partial int GetDesktopDisplayMode(int displayIndex, DisplayMode* mode); /// To be documented. - [NativeName("Src", "Line 550, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 582, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetDesktopDisplayMode")] public partial int GetDesktopDisplayMode(int displayIndex, ref DisplayMode mode); /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 605, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetCurrentDisplayMode")] public unsafe partial int GetCurrentDisplayMode(int displayIndex, DisplayMode* mode); /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 605, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetCurrentDisplayMode")] public partial int GetCurrentDisplayMode(int displayIndex, ref DisplayMode mode); /// To be documented. - [NativeName("Src", "Line 599, Column 43 in SDL_video.h")] + [NativeName("Src", "Line 631, Column 43 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetClosestDisplayMode")] public unsafe partial DisplayMode* GetClosestDisplayMode(int displayIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DisplayMode* mode, DisplayMode* closest); /// To be documented. - [NativeName("Src", "Line 599, Column 43 in SDL_video.h")] + [NativeName("Src", "Line 631, Column 43 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetClosestDisplayMode")] public unsafe partial DisplayMode* GetClosestDisplayMode(int displayIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DisplayMode* mode, ref DisplayMode closest); /// To be documented. - [NativeName("Src", "Line 599, Column 43 in SDL_video.h")] + [NativeName("Src", "Line 631, Column 43 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetClosestDisplayMode")] public unsafe partial DisplayMode* GetClosestDisplayMode(int displayIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DisplayMode mode, DisplayMode* closest); /// To be documented. - [NativeName("Src", "Line 599, Column 43 in SDL_video.h")] + [NativeName("Src", "Line 631, Column 43 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetClosestDisplayMode")] public unsafe partial DisplayMode* GetClosestDisplayMode(int displayIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DisplayMode mode, ref DisplayMode closest); /// To be documented. - [NativeName("Src", "Line 613, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 645, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetPointDisplayIndex")] public unsafe partial int GetPointDisplayIndex([Flow(Silk.NET.Core.Native.FlowDirection.In)] Point* point); /// To be documented. - [NativeName("Src", "Line 613, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 645, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetPointDisplayIndex")] public partial int GetPointDisplayIndex([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Point point); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 660, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetRectDisplayIndex")] public unsafe partial int GetRectDisplayIndex([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 660, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetRectDisplayIndex")] public partial int GetRectDisplayIndex([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 643, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 675, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowDisplayIndex")] public unsafe partial int GetWindowDisplayIndex(Window* window); /// To be documented. - [NativeName("Src", "Line 664, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 696, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowDisplayMode")] public unsafe partial int SetWindowDisplayMode(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DisplayMode* mode); /// To be documented. - [NativeName("Src", "Line 664, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 696, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowDisplayMode")] public unsafe partial int SetWindowDisplayMode(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly DisplayMode mode); /// To be documented. - [NativeName("Src", "Line 681, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 713, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowDisplayMode")] public unsafe partial int GetWindowDisplayMode(Window* window, DisplayMode* mode); /// To be documented. - [NativeName("Src", "Line 681, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 713, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowDisplayMode")] public unsafe partial int GetWindowDisplayMode(Window* window, ref DisplayMode mode); /// To be documented. - [NativeName("Src", "Line 696, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 728, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowICCProfile")] public unsafe partial void* GetWindowICCProfile(Window* window, nuint* size); /// To be documented. - [NativeName("Src", "Line 696, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 728, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowICCProfile")] public unsafe partial void* GetWindowICCProfile(Window* window, ref nuint size); /// To be documented. - [NativeName("Src", "Line 708, Column 32 in SDL_video.h")] + [NativeName("Src", "Line 740, Column 32 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowPixelFormat")] public unsafe partial uint GetWindowPixelFormat(Window* window); /// To be documented. - [NativeName("Src", "Line 781, Column 38 in SDL_video.h")] + [NativeName("Src", "Line 813, Column 38 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_CreateWindow")] public unsafe partial Window* CreateWindow([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* title, int x, int y, int w, int h, uint flags); /// To be documented. - [NativeName("Src", "Line 781, Column 38 in SDL_video.h")] + [NativeName("Src", "Line 813, Column 38 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_CreateWindow")] public unsafe partial Window* CreateWindow([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte title, int x, int y, int w, int h, uint flags); /// To be documented. - [NativeName("Src", "Line 781, Column 38 in SDL_video.h")] + [NativeName("Src", "Line 813, Column 38 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_CreateWindow")] public unsafe partial Window* CreateWindow([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string title, int x, int y, int w, int h, uint flags); /// To be documented. - [NativeName("Src", "Line 802, Column 38 in SDL_video.h")] + [NativeName("Src", "Line 834, Column 38 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_CreateWindowFrom")] public unsafe partial Window* CreateWindowFrom([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data); /// To be documented. - [NativeName("Src", "Line 802, Column 38 in SDL_video.h")] + [NativeName("Src", "Line 834, Column 38 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_CreateWindowFrom")] public unsafe partial Window* CreateWindowFrom([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 818, Column 32 in SDL_video.h")] + [NativeName("Src", "Line 850, Column 32 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowID")] public unsafe partial uint GetWindowID(Window* window); /// To be documented. - [NativeName("Src", "Line 834, Column 38 in SDL_video.h")] + [NativeName("Src", "Line 866, Column 38 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowFromID")] public unsafe partial Window* GetWindowFromID(uint id); /// To be documented. - [NativeName("Src", "Line 852, Column 32 in SDL_video.h")] + [NativeName("Src", "Line 884, Column 32 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowFlags")] public unsafe partial uint GetWindowFlags(Window* window); /// To be documented. - [NativeName("Src", "Line 866, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 898, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowTitle")] public unsafe partial void SetWindowTitle(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* title); /// To be documented. - [NativeName("Src", "Line 866, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 898, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowTitle")] public unsafe partial void SetWindowTitle(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte title); /// To be documented. - [NativeName("Src", "Line 866, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 898, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowTitle")] public unsafe partial void SetWindowTitle(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string title); /// To be documented. - [NativeName("Src", "Line 880, Column 37 in SDL_video.h")] + [NativeName("Src", "Line 912, Column 37 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowTitle")] public unsafe partial byte* GetWindowTitle(Window* window); /// To be documented. - [NativeName("Src", "Line 880, Column 37 in SDL_video.h")] + [NativeName("Src", "Line 912, Column 37 in SDL_video.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetWindowTitle")] public unsafe partial string GetWindowTitleS(Window* window); /// To be documented. - [NativeName("Src", "Line 890, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 922, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowIcon")] public unsafe partial void SetWindowIcon(Window* window, Surface* icon); /// To be documented. - [NativeName("Src", "Line 890, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 922, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowIcon")] public unsafe partial void SetWindowIcon(Window* window, ref Surface icon); /// To be documented. - [NativeName("Src", "Line 907, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 939, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowData")] public unsafe partial void* SetWindowData(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, void* userdata); /// To be documented. - [NativeName("Src", "Line 907, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 939, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowData")] public unsafe partial void* SetWindowData(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 907, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 939, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowData")] public unsafe partial void* SetWindowData(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, void* userdata); /// To be documented. - [NativeName("Src", "Line 907, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 939, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowData")] public unsafe partial void* SetWindowData(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 907, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 939, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowData")] public unsafe partial void* SetWindowData(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, void* userdata); /// To be documented. - [NativeName("Src", "Line 907, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 939, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowData")] public unsafe partial void* SetWindowData(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 922, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 954, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowData")] public unsafe partial void* GetWindowData(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name); /// To be documented. - [NativeName("Src", "Line 922, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 954, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowData")] public unsafe partial void* GetWindowData(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name); /// To be documented. - [NativeName("Src", "Line 922, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 954, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowData")] public unsafe partial void* GetWindowData(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name); /// To be documented. - [NativeName("Src", "Line 940, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 972, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowPosition")] public unsafe partial void SetWindowPosition(Window* window, int x, int y); /// To be documented. - [NativeName("Src", "Line 959, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 991, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowPosition")] public unsafe partial void GetWindowPosition(Window* window, int* x, int* y); /// To be documented. - [NativeName("Src", "Line 959, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 991, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowPosition")] public unsafe partial void GetWindowPosition(Window* window, int* x, ref int y); /// To be documented. - [NativeName("Src", "Line 959, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 991, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowPosition")] public unsafe partial void GetWindowPosition(Window* window, ref int x, int* y); /// To be documented. - [NativeName("Src", "Line 959, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 991, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowPosition")] public unsafe partial void GetWindowPosition(Window* window, ref int x, ref int y); /// To be documented. - [NativeName("Src", "Line 984, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1016, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowSize")] public unsafe partial void SetWindowSize(Window* window, int w, int h); /// To be documented. - [NativeName("Src", "Line 1011, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1043, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowSize")] public unsafe partial void GetWindowSize(Window* window, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 1011, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1043, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowSize")] public unsafe partial void GetWindowSize(Window* window, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 1011, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1043, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowSize")] public unsafe partial void GetWindowSize(Window* window, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 1011, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1043, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowSize")] public unsafe partial void GetWindowSize(Window* window, ref int w, ref int h); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, int* top, int* left, int* bottom, int* right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, int* top, int* left, int* bottom, ref int right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, int* top, int* left, ref int bottom, int* right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, int* top, int* left, ref int bottom, ref int right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, int* top, ref int left, int* bottom, int* right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, int* top, ref int left, int* bottom, ref int right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, int* top, ref int left, ref int bottom, int* right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, int* top, ref int left, ref int bottom, ref int right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, ref int top, int* left, int* bottom, int* right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, ref int top, int* left, int* bottom, ref int right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, ref int top, int* left, ref int bottom, int* right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, ref int top, int* left, ref int bottom, ref int right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, ref int top, ref int left, int* bottom, int* right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, ref int top, ref int left, int* bottom, ref int right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, ref int top, ref int left, ref int bottom, int* right); /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBordersSize")] public unsafe partial int GetWindowBordersSize(Window* window, ref int top, ref int left, ref int bottom, ref int right); /// To be documented. - [NativeName("Src", "Line 1068, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1101, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowSizeInPixels")] public unsafe partial void GetWindowSizeInPixels(Window* window, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 1068, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1101, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowSizeInPixels")] public unsafe partial void GetWindowSizeInPixels(Window* window, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 1068, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1101, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowSizeInPixels")] public unsafe partial void GetWindowSizeInPixels(Window* window, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 1068, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1101, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowSizeInPixels")] public unsafe partial void GetWindowSizeInPixels(Window* window, ref int w, ref int h); /// To be documented. - [NativeName("Src", "Line 1083, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1116, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowMinimumSize")] public unsafe partial void SetWindowMinimumSize(Window* window, int min_w, int min_h); /// To be documented. - [NativeName("Src", "Line 1100, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1133, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowMinimumSize")] public unsafe partial void GetWindowMinimumSize(Window* window, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 1100, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1133, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowMinimumSize")] public unsafe partial void GetWindowMinimumSize(Window* window, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 1100, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1133, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowMinimumSize")] public unsafe partial void GetWindowMinimumSize(Window* window, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 1100, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1133, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowMinimumSize")] public unsafe partial void GetWindowMinimumSize(Window* window, ref int w, ref int h); /// To be documented. - [NativeName("Src", "Line 1115, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1148, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowMaximumSize")] public unsafe partial void SetWindowMaximumSize(Window* window, int max_w, int max_h); /// To be documented. - [NativeName("Src", "Line 1132, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1165, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowMaximumSize")] public unsafe partial void GetWindowMaximumSize(Window* window, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 1132, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1165, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowMaximumSize")] public unsafe partial void GetWindowMaximumSize(Window* window, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 1132, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1165, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowMaximumSize")] public unsafe partial void GetWindowMaximumSize(Window* window, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 1132, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1165, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowMaximumSize")] public unsafe partial void GetWindowMaximumSize(Window* window, ref int w, ref int h); /// To be documented. - [NativeName("Src", "Line 1151, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1184, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowBordered")] public unsafe partial void SetWindowBordered(Window* window, SdlBool bordered); /// To be documented. - [NativeName("Src", "Line 1170, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1203, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowResizable")] public unsafe partial void SetWindowResizable(Window* window, SdlBool resizable); /// To be documented. - [NativeName("Src", "Line 1187, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1220, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowAlwaysOnTop")] public unsafe partial void SetWindowAlwaysOnTop(Window* window, SdlBool on_top); /// To be documented. - [NativeName("Src", "Line 1200, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1233, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_ShowWindow")] public unsafe partial void ShowWindow(Window* window); /// To be documented. - [NativeName("Src", "Line 1211, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1244, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_HideWindow")] public unsafe partial void HideWindow(Window* window); /// To be documented. - [NativeName("Src", "Line 1220, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1253, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_RaiseWindow")] public unsafe partial void RaiseWindow(Window* window); /// To be documented. - [NativeName("Src", "Line 1232, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1265, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_MaximizeWindow")] public unsafe partial void MaximizeWindow(Window* window); /// To be documented. - [NativeName("Src", "Line 1244, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1277, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_MinimizeWindow")] public unsafe partial void MinimizeWindow(Window* window); /// To be documented. - [NativeName("Src", "Line 1256, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1289, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_RestoreWindow")] public unsafe partial void RestoreWindow(Window* window); /// To be documented. - [NativeName("Src", "Line 1275, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1312, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowFullscreen")] public unsafe partial int SetWindowFullscreen(Window* window, uint flags); /// To be documented. - [NativeName("Src", "Line 1288, Column 34 in SDL_video.h")] + [NativeName("Src", "Line 1325, Column 34 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_HasWindowSurface")] public unsafe partial SdlBool HasWindowSurface(Window* window); /// To be documented. - [NativeName("Src", "Line 1315, Column 39 in SDL_video.h")] + [NativeName("Src", "Line 1356, Column 39 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowSurface")] public unsafe partial Surface* GetWindowSurface(Window* window); /// To be documented. - [NativeName("Src", "Line 1334, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1375, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_UpdateWindowSurface")] public unsafe partial int UpdateWindowSurface(Window* window); /// To be documented. - [NativeName("Src", "Line 1361, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1402, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_UpdateWindowSurfaceRects")] public unsafe partial int UpdateWindowSurfaceRects(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rects, int numrects); /// To be documented. - [NativeName("Src", "Line 1361, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1402, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_UpdateWindowSurfaceRects")] public unsafe partial int UpdateWindowSurfaceRects(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rects, int numrects); /// To be documented. - [NativeName("Src", "Line 1377, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1418, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_DestroyWindowSurface")] public unsafe partial int DestroyWindowSurface(Window* window); /// To be documented. - [NativeName("Src", "Line 1397, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1438, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowGrab")] public unsafe partial void SetWindowGrab(Window* window, SdlBool grabbed); /// To be documented. - [NativeName("Src", "Line 1428, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1469, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowKeyboardGrab")] public unsafe partial void SetWindowKeyboardGrab(Window* window, SdlBool grabbed); /// To be documented. - [NativeName("Src", "Line 1445, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1486, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowMouseGrab")] public unsafe partial void SetWindowMouseGrab(Window* window, SdlBool grabbed); /// To be documented. - [NativeName("Src", "Line 1458, Column 34 in SDL_video.h")] + [NativeName("Src", "Line 1499, Column 34 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowGrab")] public unsafe partial SdlBool GetWindowGrab(Window* window); /// To be documented. - [NativeName("Src", "Line 1471, Column 34 in SDL_video.h")] + [NativeName("Src", "Line 1512, Column 34 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowKeyboardGrab")] public unsafe partial SdlBool GetWindowKeyboardGrab(Window* window); /// To be documented. - [NativeName("Src", "Line 1484, Column 34 in SDL_video.h")] + [NativeName("Src", "Line 1525, Column 34 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowMouseGrab")] public unsafe partial SdlBool GetWindowMouseGrab(Window* window); /// To be documented. - [NativeName("Src", "Line 1496, Column 38 in SDL_video.h")] + [NativeName("Src", "Line 1537, Column 38 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetGrabbedWindow")] public unsafe partial Window* GetGrabbedWindow(); /// To be documented. - [NativeName("Src", "Line 1515, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1556, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowMouseRect")] public unsafe partial int SetWindowMouseRect(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 1515, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1556, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowMouseRect")] public unsafe partial int SetWindowMouseRect(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 1528, Column 42 in SDL_video.h")] + [NativeName("Src", "Line 1569, Column 42 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowMouseRect")] public unsafe partial Silk.NET.Maths.Rectangle* GetWindowMouseRect(Window* window); /// To be documented. - [NativeName("Src", "Line 1556, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1597, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowBrightness")] public unsafe partial int SetWindowBrightness(Window* window, float brightness); /// To be documented. - [NativeName("Src", "Line 1575, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 1616, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowBrightness")] public unsafe partial float GetWindowBrightness(Window* window); /// To be documented. - [NativeName("Src", "Line 1594, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1635, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowOpacity")] public unsafe partial int SetWindowOpacity(Window* window, float opacity); /// To be documented. - [NativeName("Src", "Line 1615, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1656, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowOpacity")] public unsafe partial int GetWindowOpacity(Window* window, float* out_opacity); /// To be documented. - [NativeName("Src", "Line 1615, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1656, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowOpacity")] public unsafe partial int GetWindowOpacity(Window* window, ref float out_opacity); /// To be documented. - [NativeName("Src", "Line 1627, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1668, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowModalFor")] public unsafe partial int SetWindowModalFor(Window* modal_window, Window* parent_window); /// To be documented. - [NativeName("Src", "Line 1644, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1685, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowInputFocus")] public unsafe partial int SetWindowInputFocus(Window* window); /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowGammaRamp")] public unsafe partial int SetWindowGammaRamp(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* blue); /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowGammaRamp")] public unsafe partial int SetWindowGammaRamp(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort blue); /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowGammaRamp")] public unsafe partial int SetWindowGammaRamp(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* blue); /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowGammaRamp")] public unsafe partial int SetWindowGammaRamp(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort blue); /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowGammaRamp")] public unsafe partial int SetWindowGammaRamp(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* blue); /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowGammaRamp")] public unsafe partial int SetWindowGammaRamp(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort blue); /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowGammaRamp")] public unsafe partial int SetWindowGammaRamp(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* blue); /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowGammaRamp")] public unsafe partial int SetWindowGammaRamp(Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly ushort blue); /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowGammaRamp")] public unsafe partial int GetWindowGammaRamp(Window* window, ushort* red, ushort* green, ushort* blue); /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowGammaRamp")] public unsafe partial int GetWindowGammaRamp(Window* window, ushort* red, ushort* green, ref ushort blue); /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowGammaRamp")] public unsafe partial int GetWindowGammaRamp(Window* window, ushort* red, ref ushort green, ushort* blue); /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowGammaRamp")] public unsafe partial int GetWindowGammaRamp(Window* window, ushort* red, ref ushort green, ref ushort blue); /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowGammaRamp")] public unsafe partial int GetWindowGammaRamp(Window* window, ref ushort red, ushort* green, ushort* blue); /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowGammaRamp")] public unsafe partial int GetWindowGammaRamp(Window* window, ref ushort red, ushort* green, ref ushort blue); /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowGammaRamp")] public unsafe partial int GetWindowGammaRamp(Window* window, ref ushort red, ref ushort green, ushort* blue); /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GetWindowGammaRamp")] public unsafe partial int GetWindowGammaRamp(Window* window, ref ushort red, ref ushort green, ref ushort blue); /// To be documented. - [NativeName("Src", "Line 1782, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1823, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowHitTest")] public unsafe partial int SetWindowHitTest(Window* window, PfnHitTest callback, void* callback_data); /// To be documented. - [NativeName("Src", "Line 1782, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1823, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_SetWindowHitTest")] public unsafe partial int SetWindowHitTest(Window* window, PfnHitTest callback, ref T0 callback_data) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1796, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1837, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_FlashWindow")] public unsafe partial int FlashWindow(Window* window, FlashOperation operation); /// To be documented. - [NativeName("Src", "Line 1811, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1852, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_DestroyWindow")] public unsafe partial void DestroyWindow(Window* window); /// To be documented. - [NativeName("Src", "Line 1830, Column 34 in SDL_video.h")] + [NativeName("Src", "Line 1871, Column 34 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_IsScreenSaverEnabled")] public partial SdlBool IsScreenSaverEnabled(); /// To be documented. - [NativeName("Src", "Line 1840, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1881, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_EnableScreenSaver")] public partial void EnableScreenSaver(); /// To be documented. - [NativeName("Src", "Line 1856, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1897, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_DisableScreenSaver")] public partial void DisableScreenSaver(); /// To be documented. - [NativeName("Src", "Line 1884, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1925, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_LoadLibrary")] public unsafe partial int GLLoadLibrary([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* path); /// To be documented. - [NativeName("Src", "Line 1884, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1925, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_LoadLibrary")] public partial int GLLoadLibrary([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte path); /// To be documented. - [NativeName("Src", "Line 1884, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1925, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_LoadLibrary")] public partial int GLLoadLibrary([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string path); /// To be documented. - [NativeName("Src", "Line 1937, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 1978, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetProcAddress")] public unsafe partial void* GLGetProcAddress([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* proc); /// To be documented. - [NativeName("Src", "Line 1937, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 1978, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetProcAddress")] public unsafe partial void* GLGetProcAddress([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte proc); /// To be documented. - [NativeName("Src", "Line 1937, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 1978, Column 31 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetProcAddress")] public unsafe partial void* GLGetProcAddress([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string proc); /// To be documented. - [NativeName("Src", "Line 1946, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1987, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_UnloadLibrary")] public partial void GLUnloadLibrary(); /// To be documented. - [NativeName("Src", "Line 1967, Column 34 in SDL_video.h")] + [NativeName("Src", "Line 2008, Column 34 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_ExtensionSupported")] public unsafe partial SdlBool GLExtensionSupported([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* extension); /// To be documented. - [NativeName("Src", "Line 1967, Column 34 in SDL_video.h")] + [NativeName("Src", "Line 2008, Column 34 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_ExtensionSupported")] public partial SdlBool GLExtensionSupported([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte extension); /// To be documented. - [NativeName("Src", "Line 1967, Column 34 in SDL_video.h")] + [NativeName("Src", "Line 2008, Column 34 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_ExtensionSupported")] public partial SdlBool GLExtensionSupported([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string extension); /// To be documented. - [NativeName("Src", "Line 1978, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2019, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_ResetAttributes")] public partial void GLResetAttributes(); /// To be documented. - [NativeName("Src", "Line 1998, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 2040, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_SetAttribute")] public partial int GLSetAttribute(GLattr attr, int value); /// To be documented. - [NativeName("Src", "Line 2013, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 2056, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetAttribute")] public unsafe partial int GLGetAttribute(GLattr attr, int* value); /// To be documented. - [NativeName("Src", "Line 2013, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 2056, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetAttribute")] public partial int GLGetAttribute(GLattr attr, ref int value); /// To be documented. - [NativeName("Src", "Line 2035, Column 39 in SDL_video.h")] + [NativeName("Src", "Line 2078, Column 39 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_CreateContext")] public unsafe partial void* GLCreateContext(Window* window); /// To be documented. - [NativeName("Src", "Line 2052, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 2095, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_MakeCurrent")] public unsafe partial int GLMakeCurrent(Window* window, void* context); /// To be documented. - [NativeName("Src", "Line 2052, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 2095, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_MakeCurrent")] public unsafe partial int GLMakeCurrent(Window* window, ref T0 context) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 2063, Column 37 in SDL_video.h")] + [NativeName("Src", "Line 2106, Column 37 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetCurrentWindow")] public unsafe partial Window* GLGetCurrentWindow(); /// To be documented. - [NativeName("Src", "Line 2075, Column 39 in SDL_video.h")] + [NativeName("Src", "Line 2118, Column 39 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetCurrentContext")] public unsafe partial void* GLGetCurrentContext(); /// To be documented. - [NativeName("Src", "Line 2097, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2141, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetDrawableSize")] public unsafe partial void GLGetDrawableSize(Window* window, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 2097, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2141, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetDrawableSize")] public unsafe partial void GLGetDrawableSize(Window* window, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 2097, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2141, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetDrawableSize")] public unsafe partial void GLGetDrawableSize(Window* window, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 2097, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2141, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetDrawableSize")] public unsafe partial void GLGetDrawableSize(Window* window, ref int w, ref int h); /// To be documented. - [NativeName("Src", "Line 2127, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 2171, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_SetSwapInterval")] public partial int GLSetSwapInterval(int interval); /// To be documented. - [NativeName("Src", "Line 2144, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 2188, Column 29 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_GetSwapInterval")] public partial int GLGetSwapInterval(); /// To be documented. - [NativeName("Src", "Line 2160, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2204, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_SwapWindow")] public unsafe partial void GLSwapWindow(Window* window); /// To be documented. - [NativeName("Src", "Line 2171, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2215, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_DeleteContext")] public unsafe partial void GLDeleteContext(void* context); /// To be documented. - [NativeName("Src", "Line 2171, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2215, Column 30 in SDL_video.h")] [NativeApi(EntryPoint = "SDL_GL_DeleteContext")] public partial void GLDeleteContext(ref T0 context) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 109, Column 29 in SDL_vulkan.h")] + [NativeName("Src", "Line 113, Column 29 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_LoadLibrary")] public unsafe partial int VulkanLoadLibrary([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* path); /// To be documented. - [NativeName("Src", "Line 109, Column 29 in SDL_vulkan.h")] + [NativeName("Src", "Line 113, Column 29 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_LoadLibrary")] public partial int VulkanLoadLibrary([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte path); /// To be documented. - [NativeName("Src", "Line 109, Column 29 in SDL_vulkan.h")] + [NativeName("Src", "Line 113, Column 29 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_LoadLibrary")] public partial int VulkanLoadLibrary([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string path); /// To be documented. - [NativeName("Src", "Line 121, Column 31 in SDL_vulkan.h")] + [NativeName("Src", "Line 125, Column 31 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_GetVkGetInstanceProcAddr")] public unsafe partial void* VulkanGetVkGetInstanceProcAddr(); /// To be documented. - [NativeName("Src", "Line 130, Column 30 in SDL_vulkan.h")] + [NativeName("Src", "Line 134, Column 30 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_UnloadLibrary")] public partial void VulkanUnloadLibrary(); /// To be documented. - [NativeName("Src", "Line 160, Column 34 in SDL_vulkan.h")] + [NativeName("Src", "Line 164, Column 34 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] public unsafe partial SdlBool VulkanGetInstanceExtensions(Window* window, uint* pCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** pNames); /// To be documented. - [NativeName("Src", "Line 160, Column 34 in SDL_vulkan.h")] + [NativeName("Src", "Line 164, Column 34 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] public unsafe partial SdlBool VulkanGetInstanceExtensions(Window* window, uint* pCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* pNames); /// To be documented. - [NativeName("Src", "Line 160, Column 34 in SDL_vulkan.h")] + [NativeName("Src", "Line 164, Column 34 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] public unsafe partial SdlBool VulkanGetInstanceExtensions(Window* window, ref uint pCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** pNames); /// To be documented. - [NativeName("Src", "Line 160, Column 34 in SDL_vulkan.h")] + [NativeName("Src", "Line 164, Column 34 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] public unsafe partial SdlBool VulkanGetInstanceExtensions(Window* window, ref uint pCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* pNames); /// To be documented. - [NativeName("Src", "Line 182, Column 34 in SDL_vulkan.h")] + [NativeName("Src", "Line 186, Column 34 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_CreateSurface")] public unsafe partial SdlBool VulkanCreateSurface(Window* window, Silk.NET.Core.Native.VkHandle instance, Silk.NET.Core.Native.VkNonDispatchableHandle* surface); /// To be documented. - [NativeName("Src", "Line 182, Column 34 in SDL_vulkan.h")] + [NativeName("Src", "Line 186, Column 34 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_CreateSurface")] public unsafe partial SdlBool VulkanCreateSurface(Window* window, Silk.NET.Core.Native.VkHandle instance, ref Silk.NET.Core.Native.VkNonDispatchableHandle surface); /// To be documented. - [NativeName("Src", "Line 204, Column 30 in SDL_vulkan.h")] + [NativeName("Src", "Line 208, Column 30 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_GetDrawableSize")] public unsafe partial void VulkanGetDrawableSize(Window* window, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 204, Column 30 in SDL_vulkan.h")] + [NativeName("Src", "Line 208, Column 30 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_GetDrawableSize")] public unsafe partial void VulkanGetDrawableSize(Window* window, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 204, Column 30 in SDL_vulkan.h")] + [NativeName("Src", "Line 208, Column 30 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_GetDrawableSize")] public unsafe partial void VulkanGetDrawableSize(Window* window, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 204, Column 30 in SDL_vulkan.h")] + [NativeName("Src", "Line 208, Column 30 in SDL_vulkan.h")] [NativeApi(EntryPoint = "SDL_Vulkan_GetDrawableSize")] public unsafe partial void VulkanGetDrawableSize(Window* window, ref int w, ref int h); @@ -8745,277 +8748,277 @@ public unsafe partial class Sdl : NativeAPI public partial void Debugbreak(); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(ref AssertData arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(ref AssertData arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(ref AssertData arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(ref AssertData arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public partial AssertState ReportAssertion(ref AssertData arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public partial AssertState ReportAssertion(ref AssertData arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public unsafe partial AssertState ReportAssertion(ref AssertData arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public partial AssertState ReportAssertion(ref AssertData arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ReportAssertion")] public partial AssertState ReportAssertion(ref AssertData arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg2, int arg3); /// To be documented. - [NativeName("Src", "Line 222, Column 30 in SDL_assert.h")] + [NativeName("Src", "Line 224, Column 30 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_SetAssertionHandler")] public unsafe partial void SetAssertionHandler(PfnAssertionHandler handler, void* userdata); /// To be documented. - [NativeName("Src", "Line 222, Column 30 in SDL_assert.h")] + [NativeName("Src", "Line 224, Column 30 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_SetAssertionHandler")] public partial void SetAssertionHandler(PfnAssertionHandler handler, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 241, Column 46 in SDL_assert.h")] + [NativeName("Src", "Line 243, Column 46 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_GetDefaultAssertionHandler")] public partial PfnAssertionHandler GetDefaultAssertionHandler(); /// To be documented. - [NativeName("Src", "Line 264, Column 46 in SDL_assert.h")] + [NativeName("Src", "Line 266, Column 46 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_GetAssertionHandler")] public unsafe partial PfnAssertionHandler GetAssertionHandler(void** puserdata); /// To be documented. - [NativeName("Src", "Line 264, Column 46 in SDL_assert.h")] + [NativeName("Src", "Line 266, Column 46 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_GetAssertionHandler")] public unsafe partial PfnAssertionHandler GetAssertionHandler(ref void* puserdata); /// To be documented. - [NativeName("Src", "Line 292, Column 48 in SDL_assert.h")] + [NativeName("Src", "Line 294, Column 48 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_GetAssertionReport")] public unsafe partial AssertData* GetAssertionReport(); /// To be documented. - [NativeName("Src", "Line 306, Column 30 in SDL_assert.h")] + [NativeName("Src", "Line 308, Column 30 in SDL_assert.h")] [NativeApi(EntryPoint = "SDL_ResetAssertionReport")] public partial void ResetAssertionReport(); /// To be documented. - [NativeName("Src", "Line 106, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 97, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicTryLock")] public unsafe partial SdlBool AtomicTryLock(int* @lock); /// To be documented. - [NativeName("Src", "Line 106, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 97, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicTryLock")] public partial SdlBool AtomicTryLock(ref int @lock); /// To be documented. - [NativeName("Src", "Line 121, Column 30 in SDL_atomic.h")] + [NativeName("Src", "Line 112, Column 30 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicLock")] public unsafe partial void AtomicLock(int* @lock); /// To be documented. - [NativeName("Src", "Line 121, Column 30 in SDL_atomic.h")] + [NativeName("Src", "Line 112, Column 30 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicLock")] public partial void AtomicLock(ref int @lock); /// To be documented. - [NativeName("Src", "Line 138, Column 30 in SDL_atomic.h")] + [NativeName("Src", "Line 129, Column 30 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicUnlock")] public unsafe partial void AtomicUnlock(int* @lock); /// To be documented. - [NativeName("Src", "Line 138, Column 30 in SDL_atomic.h")] + [NativeName("Src", "Line 129, Column 30 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicUnlock")] public partial void AtomicUnlock(ref int @lock); /// To be documented. - [NativeName("Src", "Line 183, Column 30 in SDL_atomic.h")] + [NativeName("Src", "Line 174, Column 30 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_MemoryBarrierReleaseFunction")] public partial void MemoryBarrierReleaseFunction(); /// To be documented. - [NativeName("Src", "Line 184, Column 30 in SDL_atomic.h")] + [NativeName("Src", "Line 175, Column 30 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_MemoryBarrierAcquireFunction")] public partial void MemoryBarrierAcquireFunction(); /// To be documented. - [NativeName("Src", "Line 282, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 276, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicCAS")] public unsafe partial SdlBool AtomicCAS(AtomicT* a, int oldval, int newval); /// To be documented. - [NativeName("Src", "Line 282, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 276, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicCAS")] public partial SdlBool AtomicCAS(ref AtomicT a, int oldval, int newval); /// To be documented. - [NativeName("Src", "Line 300, Column 29 in SDL_atomic.h")] + [NativeName("Src", "Line 294, Column 29 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicSet")] public unsafe partial int AtomicSet(AtomicT* a, int v); /// To be documented. - [NativeName("Src", "Line 300, Column 29 in SDL_atomic.h")] + [NativeName("Src", "Line 294, Column 29 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicSet")] public partial int AtomicSet(ref AtomicT a, int v); /// To be documented. - [NativeName("Src", "Line 315, Column 29 in SDL_atomic.h")] + [NativeName("Src", "Line 309, Column 29 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicGet")] public unsafe partial int AtomicGet(AtomicT* a); /// To be documented. - [NativeName("Src", "Line 315, Column 29 in SDL_atomic.h")] + [NativeName("Src", "Line 309, Column 29 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicGet")] public partial int AtomicGet(ref AtomicT a); /// To be documented. - [NativeName("Src", "Line 334, Column 29 in SDL_atomic.h")] + [NativeName("Src", "Line 328, Column 29 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicAdd")] public unsafe partial int AtomicAdd(AtomicT* a, int v); /// To be documented. - [NativeName("Src", "Line 334, Column 29 in SDL_atomic.h")] + [NativeName("Src", "Line 328, Column 29 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicAdd")] public partial int AtomicAdd(ref AtomicT a, int v); /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicCASPtr")] public unsafe partial SdlBool AtomicCASPtr(void** a, void* oldval, void* newval); /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicCASPtr")] public unsafe partial SdlBool AtomicCASPtr(void** a, void* oldval, ref T0 newval) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicCASPtr")] public unsafe partial SdlBool AtomicCASPtr(void** a, ref T0 oldval, void* newval) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicCASPtr")] public unsafe partial SdlBool AtomicCASPtr(void** a, ref T0 oldval, ref T1 newval) where T0 : unmanaged where T1 : unmanaged; /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicCASPtr")] public unsafe partial SdlBool AtomicCASPtr(ref void* a, void* oldval, void* newval); /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicCASPtr")] public unsafe partial SdlBool AtomicCASPtr(ref void* a, void* oldval, ref T0 newval) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicCASPtr")] public unsafe partial SdlBool AtomicCASPtr(ref void* a, ref T0 oldval, void* newval) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicCASPtr")] public unsafe partial SdlBool AtomicCASPtr(ref void* a, ref T0 oldval, ref T1 newval) where T0 : unmanaged where T1 : unmanaged; /// To be documented. - [NativeName("Src", "Line 387, Column 31 in SDL_atomic.h")] + [NativeName("Src", "Line 381, Column 31 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicSetPtr")] public unsafe partial void* AtomicSetPtr(void** a, void* v); /// To be documented. - [NativeName("Src", "Line 387, Column 31 in SDL_atomic.h")] + [NativeName("Src", "Line 381, Column 31 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicSetPtr")] public unsafe partial void* AtomicSetPtr(void** a, ref T0 v) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 387, Column 31 in SDL_atomic.h")] + [NativeName("Src", "Line 381, Column 31 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicSetPtr")] public unsafe partial void* AtomicSetPtr(ref void* a, void* v); /// To be documented. - [NativeName("Src", "Line 387, Column 31 in SDL_atomic.h")] + [NativeName("Src", "Line 381, Column 31 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicSetPtr")] public unsafe partial void* AtomicSetPtr(ref void* a, ref T0 v) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 403, Column 31 in SDL_atomic.h")] + [NativeName("Src", "Line 397, Column 31 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicGetPtr")] public unsafe partial void* AtomicGetPtr(void** a); /// To be documented. - [NativeName("Src", "Line 403, Column 31 in SDL_atomic.h")] + [NativeName("Src", "Line 397, Column 31 in SDL_atomic.h")] [NativeApi(EntryPoint = "SDL_AtomicGetPtr")] public unsafe partial void* AtomicGetPtr(ref void* a); @@ -9110,631 +9113,631 @@ public unsafe partial class Sdl : NativeAPI public unsafe partial int CondWaitTimeout(Cond* cond, Mutex* mutex, uint ms); /// To be documented. - [NativeName("Src", "Line 208, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 210, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThread")] public unsafe partial Thread* CreateThread(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, void* data); /// To be documented. - [NativeName("Src", "Line 208, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 210, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThread")] public unsafe partial Thread* CreateThread(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, ref T0 data) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 208, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 210, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThread")] public unsafe partial Thread* CreateThread(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, void* data); /// To be documented. - [NativeName("Src", "Line 208, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 210, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThread")] public unsafe partial Thread* CreateThread(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, ref T0 data) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 208, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 210, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThread")] public unsafe partial Thread* CreateThread(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, void* data); /// To be documented. - [NativeName("Src", "Line 208, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 210, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThread")] public unsafe partial Thread* CreateThread(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, ref T0 data) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 254, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 256, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThreadWithStackSize")] public unsafe partial Thread* CreateThreadWithStackSize(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, nuint stacksize, void* data); /// To be documented. - [NativeName("Src", "Line 254, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 256, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThreadWithStackSize")] public unsafe partial Thread* CreateThreadWithStackSize(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, nuint stacksize, ref T0 data) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 254, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 256, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThreadWithStackSize")] public unsafe partial Thread* CreateThreadWithStackSize(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, nuint stacksize, void* data); /// To be documented. - [NativeName("Src", "Line 254, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 256, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThreadWithStackSize")] public unsafe partial Thread* CreateThreadWithStackSize(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, nuint stacksize, ref T0 data) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 254, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 256, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThreadWithStackSize")] public unsafe partial Thread* CreateThreadWithStackSize(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, nuint stacksize, void* data); /// To be documented. - [NativeName("Src", "Line 254, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 256, Column 1 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_CreateThreadWithStackSize")] public unsafe partial Thread* CreateThreadWithStackSize(PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, nuint stacksize, ref T0 data) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 272, Column 37 in SDL_thread.h")] + [NativeName("Src", "Line 274, Column 37 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_GetThreadName")] public unsafe partial byte* GetThreadName(Thread* thread); /// To be documented. - [NativeName("Src", "Line 272, Column 37 in SDL_thread.h")] + [NativeName("Src", "Line 274, Column 37 in SDL_thread.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetThreadName")] public unsafe partial string GetThreadNameS(Thread* thread); /// To be documented. - [NativeName("Src", "Line 290, Column 38 in SDL_thread.h")] + [NativeName("Src", "Line 292, Column 38 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_ThreadID")] public partial uint ThreadID(); /// To be documented. - [NativeName("Src", "Line 307, Column 38 in SDL_thread.h")] + [NativeName("Src", "Line 309, Column 38 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_GetThreadID")] public unsafe partial uint GetThreadID(Thread* thread); /// To be documented. - [NativeName("Src", "Line 322, Column 29 in SDL_thread.h")] + [NativeName("Src", "Line 324, Column 29 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_SetThreadPriority")] public partial int SetThreadPriority(ThreadPriority priority); /// To be documented. - [NativeName("Src", "Line 357, Column 30 in SDL_thread.h")] + [NativeName("Src", "Line 359, Column 30 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_WaitThread")] public unsafe partial void WaitThread(Thread* thread, int* status); /// To be documented. - [NativeName("Src", "Line 357, Column 30 in SDL_thread.h")] + [NativeName("Src", "Line 359, Column 30 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_WaitThread")] public unsafe partial void WaitThread(Thread* thread, ref int status); /// To be documented. - [NativeName("Src", "Line 393, Column 30 in SDL_thread.h")] + [NativeName("Src", "Line 395, Column 30 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_DetachThread")] public unsafe partial void DetachThread(Thread* thread); /// To be documented. - [NativeName("Src", "Line 408, Column 35 in SDL_thread.h")] + [NativeName("Src", "Line 410, Column 35 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_TLSCreate")] public partial uint TLSCreate(); /// To be documented. - [NativeName("Src", "Line 422, Column 32 in SDL_thread.h")] + [NativeName("Src", "Line 424, Column 32 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_TLSGet")] public unsafe partial void* TLSGet(uint id); /// To be documented. - [NativeName("Src", "Line 447, Column 29 in SDL_thread.h")] + [NativeName("Src", "Line 451, Column 29 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_TLSSet")] public unsafe partial int TLSSet(uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* value, PfnFreeFunc destructor); /// To be documented. - [NativeName("Src", "Line 447, Column 29 in SDL_thread.h")] + [NativeName("Src", "Line 451, Column 29 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_TLSSet")] public partial int TLSSet(uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 value, PfnFreeFunc destructor) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 454, Column 30 in SDL_thread.h")] + [NativeName("Src", "Line 458, Column 30 in SDL_thread.h")] [NativeApi(EntryPoint = "SDL_TLSCleanup")] public partial void TLSCleanup(); /// To be documented. - [NativeName("Src", "Line 276, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 273, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetNumAudioDrivers")] public partial int GetNumAudioDrivers(); /// To be documented. - [NativeName("Src", "Line 298, Column 37 in SDL_audio.h")] + [NativeName("Src", "Line 295, Column 37 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetAudioDriver")] public unsafe partial byte* GetAudioDriver(int index); /// To be documented. - [NativeName("Src", "Line 298, Column 37 in SDL_audio.h")] + [NativeName("Src", "Line 295, Column 37 in SDL_audio.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetAudioDriver")] public partial string GetAudioDriverS(int index); /// To be documented. - [NativeName("Src", "Line 325, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 322, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_AudioInit")] public unsafe partial int AudioInit([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* driver_name); /// To be documented. - [NativeName("Src", "Line 325, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 322, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_AudioInit")] public partial int AudioInit([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte driver_name); /// To be documented. - [NativeName("Src", "Line 325, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 322, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_AudioInit")] public partial int AudioInit([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string driver_name); /// To be documented. - [NativeName("Src", "Line 339, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 336, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_AudioQuit")] public partial void AudioQuit(); /// To be documented. - [NativeName("Src", "Line 358, Column 37 in SDL_audio.h")] + [NativeName("Src", "Line 355, Column 37 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetCurrentAudioDriver")] public unsafe partial byte* GetCurrentAudioDriver(); /// To be documented. - [NativeName("Src", "Line 358, Column 37 in SDL_audio.h")] + [NativeName("Src", "Line 355, Column 37 in SDL_audio.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetCurrentAudioDriver")] public partial string GetCurrentAudioDriverS(); /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 404, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudio")] public unsafe partial int OpenAudio(AudioSpec* desired, AudioSpec* obtained); /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 404, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudio")] public unsafe partial int OpenAudio(AudioSpec* desired, ref AudioSpec obtained); /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 404, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudio")] public unsafe partial int OpenAudio(ref AudioSpec desired, AudioSpec* obtained); /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 404, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudio")] public partial int OpenAudio(ref AudioSpec desired, ref AudioSpec obtained); /// To be documented. - [NativeName("Src", "Line 465, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 462, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetNumAudioDevices")] public partial int GetNumAudioDevices(int iscapture); /// To be documented. - [NativeName("Src", "Line 492, Column 37 in SDL_audio.h")] + [NativeName("Src", "Line 489, Column 37 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetAudioDeviceName")] public unsafe partial byte* GetAudioDeviceName(int index, int iscapture); /// To be documented. - [NativeName("Src", "Line 492, Column 37 in SDL_audio.h")] + [NativeName("Src", "Line 489, Column 37 in SDL_audio.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetAudioDeviceName")] public partial string GetAudioDeviceNameS(int index, int iscapture); /// To be documented. - [NativeName("Src", "Line 518, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 515, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetAudioDeviceSpec")] public unsafe partial int GetAudioDeviceSpec(int index, int iscapture, AudioSpec* spec); /// To be documented. - [NativeName("Src", "Line 518, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 515, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetAudioDeviceSpec")] public partial int GetAudioDeviceSpec(int index, int iscapture, ref AudioSpec spec); /// To be documented. - [NativeName("Src", "Line 553, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 550, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetDefaultAudioInfo")] public unsafe partial int GetDefaultAudioInfo(byte** name, AudioSpec* spec, int iscapture); /// To be documented. - [NativeName("Src", "Line 553, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 550, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetDefaultAudioInfo")] public unsafe partial int GetDefaultAudioInfo(byte** name, ref AudioSpec spec, int iscapture); /// To be documented. - [NativeName("Src", "Line 553, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 550, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetDefaultAudioInfo")] public unsafe partial int GetDefaultAudioInfo(ref byte* name, AudioSpec* spec, int iscapture); /// To be documented. - [NativeName("Src", "Line 553, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 550, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetDefaultAudioInfo")] public unsafe partial int GetDefaultAudioInfo(ref byte* name, ref AudioSpec spec, int iscapture); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public unsafe partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] AudioSpec* desired, AudioSpec* obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public unsafe partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] AudioSpec* desired, ref AudioSpec obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public unsafe partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly AudioSpec desired, AudioSpec* obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public unsafe partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly AudioSpec desired, ref AudioSpec obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public unsafe partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] AudioSpec* desired, AudioSpec* obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public unsafe partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] AudioSpec* desired, ref AudioSpec obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public unsafe partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly AudioSpec desired, AudioSpec* obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly AudioSpec desired, ref AudioSpec obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public unsafe partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] AudioSpec* desired, AudioSpec* obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public unsafe partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] AudioSpec* desired, ref AudioSpec obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public unsafe partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly AudioSpec desired, AudioSpec* obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_OpenAudioDevice")] public partial uint OpenAudioDevice([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly AudioSpec desired, ref AudioSpec obtained, int allowed_changes); /// To be documented. - [NativeName("Src", "Line 709, Column 41 in SDL_audio.h")] + [NativeName("Src", "Line 706, Column 41 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetAudioStatus")] public partial AudioStatus GetAudioStatus(); /// To be documented. - [NativeName("Src", "Line 722, Column 41 in SDL_audio.h")] + [NativeName("Src", "Line 719, Column 41 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetAudioDeviceStatus")] public partial AudioStatus GetAudioDeviceStatus(uint dev); /// To be documented. - [NativeName("Src", "Line 755, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 752, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_PauseAudio")] public partial void PauseAudio(int pause_on); /// To be documented. - [NativeName("Src", "Line 785, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 782, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_PauseAudioDevice")] public partial void PauseAudioDevice(uint dev, int pause_on); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(RWops* src, int freesrc, AudioSpec* spec, byte** audio_buf, uint* audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(RWops* src, int freesrc, AudioSpec* spec, byte** audio_buf, ref uint audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(RWops* src, int freesrc, AudioSpec* spec, ref byte* audio_buf, uint* audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(RWops* src, int freesrc, AudioSpec* spec, ref byte* audio_buf, ref uint audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(RWops* src, int freesrc, ref AudioSpec spec, byte** audio_buf, uint* audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(RWops* src, int freesrc, ref AudioSpec spec, byte** audio_buf, ref uint audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(RWops* src, int freesrc, ref AudioSpec spec, ref byte* audio_buf, uint* audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(RWops* src, int freesrc, ref AudioSpec spec, ref byte* audio_buf, ref uint audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(ref RWops src, int freesrc, AudioSpec* spec, byte** audio_buf, uint* audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(ref RWops src, int freesrc, AudioSpec* spec, byte** audio_buf, ref uint audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(ref RWops src, int freesrc, AudioSpec* spec, ref byte* audio_buf, uint* audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(ref RWops src, int freesrc, AudioSpec* spec, ref byte* audio_buf, ref uint audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(ref RWops src, int freesrc, ref AudioSpec spec, byte** audio_buf, uint* audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(ref RWops src, int freesrc, ref AudioSpec spec, byte** audio_buf, ref uint audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(ref RWops src, int freesrc, ref AudioSpec spec, ref byte* audio_buf, uint* audio_len); /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LoadWAV_RW")] public unsafe partial AudioSpec* LoadWAVRW(ref RWops src, int freesrc, ref AudioSpec spec, ref byte* audio_buf, ref uint audio_len); /// To be documented. - [NativeName("Src", "Line 898, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 896, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_FreeWAV")] public unsafe partial void FreeWAV(byte* audio_buf); /// To be documented. - [NativeName("Src", "Line 898, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 896, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_FreeWAV")] public partial void FreeWAV(ref byte audio_buf); /// To be documented. - [NativeName("Src", "Line 898, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 896, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_FreeWAV")] public partial void FreeWAV([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string audio_buf); /// To be documented. - [NativeName("Src", "Line 932, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 931, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_BuildAudioCVT")] public unsafe partial int BuildAudioCVT(AudioCVT* cvt, ushort src_format, byte src_channels, int src_rate, ushort dst_format, byte dst_channels, int dst_rate); /// To be documented. - [NativeName("Src", "Line 932, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 931, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_BuildAudioCVT")] public partial int BuildAudioCVT(ref AudioCVT cvt, ushort src_format, byte src_channels, int src_rate, ushort dst_format, byte dst_channels, int dst_rate); /// To be documented. - [NativeName("Src", "Line 978, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 977, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_ConvertAudio")] public unsafe partial int ConvertAudio(AudioCVT* cvt); /// To be documented. - [NativeName("Src", "Line 978, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 977, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_ConvertAudio")] public partial int ConvertAudio(ref AudioCVT cvt); /// To be documented. - [NativeName("Src", "Line 1011, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 1010, Column 43 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_NewAudioStream")] public unsafe partial AudioStream* NewAudioStream(ushort src_format, byte src_channels, int src_rate, ushort dst_format, byte dst_channels, int dst_rate); /// To be documented. - [NativeName("Src", "Line 1035, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 1034, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_AudioStreamPut")] public unsafe partial int AudioStreamPut(AudioStream* stream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* buf, int len); /// To be documented. - [NativeName("Src", "Line 1035, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 1034, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_AudioStreamPut")] public unsafe partial int AudioStreamPut(AudioStream* stream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 buf, int len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1054, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 1053, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_AudioStreamGet")] public unsafe partial int AudioStreamGet(AudioStream* stream, void* buf, int len); /// To be documented. - [NativeName("Src", "Line 1054, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 1053, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_AudioStreamGet")] public unsafe partial int AudioStreamGet(AudioStream* stream, ref T0 buf, int len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1072, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 1071, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_AudioStreamAvailable")] public unsafe partial int AudioStreamAvailable(AudioStream* stream); /// To be documented. - [NativeName("Src", "Line 1091, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 1090, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_AudioStreamFlush")] public unsafe partial int AudioStreamFlush(AudioStream* stream); /// To be documented. - [NativeName("Src", "Line 1105, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1104, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_AudioStreamClear")] public unsafe partial void AudioStreamClear(AudioStream* stream); /// To be documented. - [NativeName("Src", "Line 1119, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1118, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_FreeAudioStream")] public unsafe partial void FreeAudioStream(AudioStream* stream); /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudio")] public unsafe partial void MixAudio(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudio")] public unsafe partial void MixAudio(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudio")] public unsafe partial void MixAudio(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudio")] public unsafe partial void MixAudio(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudio")] public partial void MixAudio(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudio")] public partial void MixAudio(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudio")] public unsafe partial void MixAudio([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudio")] public partial void MixAudio([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudio")] public partial void MixAudio([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudioFormat")] public unsafe partial void MixAudioFormat(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, ushort format, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudioFormat")] public unsafe partial void MixAudioFormat(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, ushort format, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudioFormat")] public unsafe partial void MixAudioFormat(byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, ushort format, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudioFormat")] public unsafe partial void MixAudioFormat(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, ushort format, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudioFormat")] public partial void MixAudioFormat(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, ushort format, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudioFormat")] public partial void MixAudioFormat(ref byte dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, ushort format, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudioFormat")] public unsafe partial void MixAudioFormat([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, ushort format, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudioFormat")] public partial void MixAudioFormat([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte src, ushort format, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_MixAudioFormat")] public partial void MixAudioFormat([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, ushort format, uint len, int volume); /// To be documented. - [NativeName("Src", "Line 1229, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 1231, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_QueueAudio")] public unsafe partial int QueueAudio(uint dev, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, uint len); /// To be documented. - [NativeName("Src", "Line 1229, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 1231, Column 29 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_QueueAudio")] public partial int QueueAudio(uint dev, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, uint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1277, Column 32 in SDL_audio.h")] + [NativeName("Src", "Line 1279, Column 32 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_DequeueAudio")] public unsafe partial uint DequeueAudio(uint dev, void* data, uint len); /// To be documented. - [NativeName("Src", "Line 1277, Column 32 in SDL_audio.h")] + [NativeName("Src", "Line 1279, Column 32 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_DequeueAudio")] public partial uint DequeueAudio(uint dev, ref T0 data, uint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1311, Column 32 in SDL_audio.h")] + [NativeName("Src", "Line 1313, Column 32 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_GetQueuedAudioSize")] public partial uint GetQueuedAudioSize(uint dev); /// To be documented. - [NativeName("Src", "Line 1345, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1347, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_ClearQueuedAudio")] public partial void ClearQueuedAudio(uint dev); /// To be documented. - [NativeName("Src", "Line 1376, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1378, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LockAudio")] public partial void LockAudio(); /// To be documented. - [NativeName("Src", "Line 1415, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1417, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_LockAudioDevice")] public partial void LockAudioDevice(uint dev); /// To be documented. - [NativeName("Src", "Line 1434, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1436, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_UnlockAudio")] public partial void UnlockAudio(); /// To be documented. - [NativeName("Src", "Line 1448, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1450, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_UnlockAudioDevice")] public partial void UnlockAudioDevice(uint dev); /// To be documented. - [NativeName("Src", "Line 1466, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1468, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_CloseAudio")] public partial void CloseAudio(); /// To be documented. - [NativeName("Src", "Line 1490, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1492, Column 30 in SDL_audio.h")] [NativeApi(EntryPoint = "SDL_CloseAudioDevice")] public partial void CloseAudioDevice(uint dev); @@ -9801,276 +9804,276 @@ public unsafe partial class Sdl : NativeAPI public partial SdlBool HasPrimarySelectionText(); /// To be documented. - [NativeName("Src", "Line 149, Column 29 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 158, Column 29 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_GetCPUCount")] public partial int GetCPUCount(); /// To be documented. - [NativeName("Src", "Line 161, Column 29 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 170, Column 29 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_GetCPUCacheLineSize")] public partial int GetCPUCacheLineSize(); /// To be documented. - [NativeName("Src", "Line 183, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 192, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasRDTSC")] public partial SdlBool HasRDTSC(); /// To be documented. - [NativeName("Src", "Line 206, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 215, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasAltiVec")] public partial SdlBool HasAltiVec(); /// To be documented. - [NativeName("Src", "Line 228, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 237, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasMMX")] public partial SdlBool HasMMX(); /// To be documented. - [NativeName("Src", "Line 250, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 259, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_Has3DNow")] public partial SdlBool Has3DNow(); /// To be documented. - [NativeName("Src", "Line 272, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 281, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasSSE")] public partial SdlBool HasSSE(); /// To be documented. - [NativeName("Src", "Line 294, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 303, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasSSE2")] public partial SdlBool HasSSE2(); /// To be documented. - [NativeName("Src", "Line 316, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 325, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasSSE3")] public partial SdlBool HasSSE3(); /// To be documented. - [NativeName("Src", "Line 338, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 347, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasSSE41")] public partial SdlBool HasSSE41(); /// To be documented. - [NativeName("Src", "Line 360, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 369, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasSSE42")] public partial SdlBool HasSSE42(); /// To be documented. - [NativeName("Src", "Line 382, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 391, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasAVX")] public partial SdlBool HasAVX(); /// To be documented. - [NativeName("Src", "Line 404, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 413, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasAVX2")] public partial SdlBool HasAVX2(); /// To be documented. - [NativeName("Src", "Line 417, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 426, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasAVX512F")] public partial SdlBool HasAVX512F(); /// To be documented. - [NativeName("Src", "Line 432, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 441, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasARMSIMD")] public partial SdlBool HasARMSIMD(); /// To be documented. - [NativeName("Src", "Line 443, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 452, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasNEON")] public partial SdlBool HasNEON(); /// To be documented. - [NativeName("Src", "Line 456, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 465, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasLSX")] public partial SdlBool HasLSX(); /// To be documented. - [NativeName("Src", "Line 469, Column 34 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 478, Column 34 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_HasLASX")] public partial SdlBool HasLASX(); /// To be documented. - [NativeName("Src", "Line 478, Column 29 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 487, Column 29 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_GetSystemRAM")] public partial int GetSystemRAM(); /// To be documented. - [NativeName("Src", "Line 497, Column 32 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 506, Column 32 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_SIMDGetAlignment")] public partial nuint SIMDGetAlignment(); /// To be documented. - [NativeName("Src", "Line 536, Column 32 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 545, Column 32 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_SIMDAlloc")] public unsafe partial void* SIMDAlloc(nuint len); /// To be documented. - [NativeName("Src", "Line 560, Column 32 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 569, Column 32 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_SIMDRealloc")] public unsafe partial void* SIMDRealloc(void* mem, nuint len); /// To be documented. - [NativeName("Src", "Line 560, Column 32 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 569, Column 32 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_SIMDRealloc")] public unsafe partial void* SIMDRealloc(ref T0 mem, nuint len) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 584, Column 30 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 593, Column 30 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_SIMDFree")] public unsafe partial void SIMDFree(void* ptr); /// To be documented. - [NativeName("Src", "Line 584, Column 30 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 593, Column 30 in SDL_cpuinfo.h")] [NativeApi(EntryPoint = "SDL_SIMDFree")] public partial void SIMDFree(ref T0 ptr) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 64, Column 38 in SDL_keyboard.h")] + [NativeName("Src", "Line 65, Column 38 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetKeyboardFocus")] public unsafe partial Window* GetKeyboardFocus(); /// To be documented. - [NativeName("Src", "Line 95, Column 38 in SDL_keyboard.h")] + [NativeName("Src", "Line 96, Column 38 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetKeyboardState")] public unsafe partial byte* GetKeyboardState(int* numkeys); /// To be documented. - [NativeName("Src", "Line 95, Column 38 in SDL_keyboard.h")] + [NativeName("Src", "Line 96, Column 38 in SDL_keyboard.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetKeyboardState")] public unsafe partial string GetKeyboardStateS(int* numkeys); /// To be documented. - [NativeName("Src", "Line 95, Column 38 in SDL_keyboard.h")] + [NativeName("Src", "Line 96, Column 38 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetKeyboardState")] public unsafe partial byte* GetKeyboardState(ref int numkeys); /// To be documented. - [NativeName("Src", "Line 95, Column 38 in SDL_keyboard.h")] + [NativeName("Src", "Line 96, Column 38 in SDL_keyboard.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetKeyboardState")] public partial string GetKeyboardStateS(ref int numkeys); /// To be documented. - [NativeName("Src", "Line 106, Column 30 in SDL_keyboard.h")] + [NativeName("Src", "Line 107, Column 30 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_ResetKeyboard")] public partial void ResetKeyboard(); /// To be documented. - [NativeName("Src", "Line 119, Column 36 in SDL_keyboard.h")] + [NativeName("Src", "Line 120, Column 36 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetModState")] public partial Keymod GetModState(); /// To be documented. - [NativeName("Src", "Line 138, Column 30 in SDL_keyboard.h")] + [NativeName("Src", "Line 139, Column 30 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_SetModState")] public partial void SetModState(Keymod modstate); /// To be documented. - [NativeName("Src", "Line 154, Column 37 in SDL_keyboard.h")] + [NativeName("Src", "Line 155, Column 37 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetKeyFromScancode")] public partial int GetKeyFromScancode(Scancode scancode); /// To be documented. - [NativeName("Src", "Line 170, Column 38 in SDL_keyboard.h")] + [NativeName("Src", "Line 171, Column 38 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetScancodeFromKey")] public partial Scancode GetScancodeFromKey(int key); /// To be documented. - [NativeName("Src", "Line 195, Column 37 in SDL_keyboard.h")] + [NativeName("Src", "Line 196, Column 37 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetScancodeName")] public unsafe partial byte* GetScancodeName(Scancode scancode); /// To be documented. - [NativeName("Src", "Line 195, Column 37 in SDL_keyboard.h")] + [NativeName("Src", "Line 196, Column 37 in SDL_keyboard.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetScancodeName")] public partial string GetScancodeNameS(Scancode scancode); /// To be documented. - [NativeName("Src", "Line 210, Column 38 in SDL_keyboard.h")] + [NativeName("Src", "Line 211, Column 38 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetScancodeFromName")] public unsafe partial Scancode GetScancodeFromName([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name); /// To be documented. - [NativeName("Src", "Line 210, Column 38 in SDL_keyboard.h")] + [NativeName("Src", "Line 211, Column 38 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetScancodeFromName")] public partial Scancode GetScancodeFromName([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name); /// To be documented. - [NativeName("Src", "Line 210, Column 38 in SDL_keyboard.h")] + [NativeName("Src", "Line 211, Column 38 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetScancodeFromName")] public partial Scancode GetScancodeFromName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name); /// To be documented. - [NativeName("Src", "Line 229, Column 37 in SDL_keyboard.h")] + [NativeName("Src", "Line 230, Column 37 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetKeyName")] public unsafe partial byte* GetKeyName(int key); /// To be documented. - [NativeName("Src", "Line 229, Column 37 in SDL_keyboard.h")] + [NativeName("Src", "Line 230, Column 37 in SDL_keyboard.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetKeyName")] public partial string GetKeyNameS(int key); /// To be documented. - [NativeName("Src", "Line 244, Column 37 in SDL_keyboard.h")] + [NativeName("Src", "Line 245, Column 37 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetKeyFromName")] public unsafe partial int GetKeyFromName([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name); /// To be documented. - [NativeName("Src", "Line 244, Column 37 in SDL_keyboard.h")] + [NativeName("Src", "Line 245, Column 37 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetKeyFromName")] public partial int GetKeyFromName([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name); /// To be documented. - [NativeName("Src", "Line 244, Column 37 in SDL_keyboard.h")] + [NativeName("Src", "Line 245, Column 37 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_GetKeyFromName")] public partial int GetKeyFromName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name); /// To be documented. - [NativeName("Src", "Line 261, Column 30 in SDL_keyboard.h")] + [NativeName("Src", "Line 266, Column 30 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_StartTextInput")] public partial void StartTextInput(); /// To be documented. - [NativeName("Src", "Line 272, Column 34 in SDL_keyboard.h")] + [NativeName("Src", "Line 277, Column 34 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_IsTextInputActive")] public partial SdlBool IsTextInputActive(); /// To be documented. - [NativeName("Src", "Line 281, Column 30 in SDL_keyboard.h")] + [NativeName("Src", "Line 286, Column 30 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_StopTextInput")] public partial void StopTextInput(); /// To be documented. - [NativeName("Src", "Line 291, Column 30 in SDL_keyboard.h")] + [NativeName("Src", "Line 296, Column 30 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_ClearComposition")] public partial void ClearComposition(); /// To be documented. - [NativeName("Src", "Line 298, Column 34 in SDL_keyboard.h")] + [NativeName("Src", "Line 303, Column 34 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_IsTextInputShown")] public partial SdlBool IsTextInputShown(); /// To be documented. - [NativeName("Src", "Line 320, Column 30 in SDL_keyboard.h")] + [NativeName("Src", "Line 326, Column 30 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_SetTextInputRect")] public unsafe partial void SetTextInputRect([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 320, Column 30 in SDL_keyboard.h")] + [NativeName("Src", "Line 326, Column 30 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_SetTextInputRect")] public partial void SetTextInputRect([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 333, Column 34 in SDL_keyboard.h")] + [NativeName("Src", "Line 339, Column 34 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_HasScreenKeyboardSupport")] public partial SdlBool HasScreenKeyboardSupport(); /// To be documented. - [NativeName("Src", "Line 345, Column 34 in SDL_keyboard.h")] + [NativeName("Src", "Line 351, Column 34 in SDL_keyboard.h")] [NativeApi(EntryPoint = "SDL_IsScreenKeyboardShown")] public unsafe partial SdlBool IsScreenKeyboardShown(Window* window); @@ -10250,1136 +10253,1136 @@ public unsafe partial class Sdl : NativeAPI public partial int ShowCursor(int toggle); /// To be documented. - [NativeName("Src", "Line 74, Column 30 in SDL_guid.h")] + [NativeName("Src", "Line 81, Column 30 in SDL_guid.h")] [NativeApi(EntryPoint = "SDL_GUIDToString")] - public unsafe partial void GUIDToString(GUID guid, byte* pszGUID, int cbGUID); + public unsafe partial void GUIDToString(Guid guid, byte* pszGUID, int cbGUID); /// To be documented. - [NativeName("Src", "Line 74, Column 30 in SDL_guid.h")] + [NativeName("Src", "Line 81, Column 30 in SDL_guid.h")] [NativeApi(EntryPoint = "SDL_GUIDToString")] - public partial void GUIDToString(GUID guid, ref byte pszGUID, int cbGUID); + public partial void GUIDToString(Guid guid, ref byte pszGUID, int cbGUID); /// To be documented. - [NativeName("Src", "Line 74, Column 30 in SDL_guid.h")] + [NativeName("Src", "Line 81, Column 30 in SDL_guid.h")] [NativeApi(EntryPoint = "SDL_GUIDToString")] - public partial void GUIDToString(GUID guid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszGUID, int cbGUID); + public partial void GUIDToString(Guid guid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszGUID, int cbGUID); /// To be documented. - [NativeName("Src", "Line 90, Column 34 in SDL_guid.h")] + [NativeName("Src", "Line 97, Column 34 in SDL_guid.h")] [NativeApi(EntryPoint = "SDL_GUIDFromString")] - public unsafe partial GUID GUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pchGUID); + public unsafe partial Guid GUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pchGUID); /// To be documented. - [NativeName("Src", "Line 90, Column 34 in SDL_guid.h")] + [NativeName("Src", "Line 97, Column 34 in SDL_guid.h")] [NativeApi(EntryPoint = "SDL_GUIDFromString")] - public partial GUID GUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte pchGUID); + public partial Guid GUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte pchGUID); /// To be documented. - [NativeName("Src", "Line 90, Column 34 in SDL_guid.h")] + [NativeName("Src", "Line 97, Column 34 in SDL_guid.h")] [NativeApi(EntryPoint = "SDL_GUIDFromString")] - public partial GUID GUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pchGUID); + public partial Guid GUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pchGUID); /// To be documented. - [NativeName("Src", "Line 138, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 148, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_LockJoysticks")] public partial void LockJoysticks(); /// To be documented. - [NativeName("Src", "Line 153, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 163, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_UnlockJoysticks")] public partial void UnlockJoysticks(); /// To be documented. - [NativeName("Src", "Line 167, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 177, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_NumJoysticks")] public partial int NumJoysticks(); /// To be documented. - [NativeName("Src", "Line 184, Column 37 in SDL_joystick.h")] + [NativeName("Src", "Line 194, Column 37 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickNameForIndex")] public unsafe partial byte* JoystickNameForIndex(int device_index); /// To be documented. - [NativeName("Src", "Line 184, Column 37 in SDL_joystick.h")] + [NativeName("Src", "Line 194, Column 37 in SDL_joystick.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_JoystickNameForIndex")] public partial string JoystickNameForIndexS(int device_index); /// To be documented. - [NativeName("Src", "Line 201, Column 37 in SDL_joystick.h")] + [NativeName("Src", "Line 211, Column 37 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickPathForIndex")] public unsafe partial byte* JoystickPathForIndex(int device_index); /// To be documented. - [NativeName("Src", "Line 201, Column 37 in SDL_joystick.h")] + [NativeName("Src", "Line 211, Column 37 in SDL_joystick.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_JoystickPathForIndex")] public partial string JoystickPathForIndexS(int device_index); /// To be documented. - [NativeName("Src", "Line 209, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 219, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetDevicePlayerIndex")] public partial int JoystickGetDevicePlayerIndex(int device_index); /// To be documented. - [NativeName("Src", "Line 227, Column 42 in SDL_joystick.h")] + [NativeName("Src", "Line 237, Column 42 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetDeviceGUID")] - public partial GUID JoystickGetDeviceGUID(int device_index); + public partial Guid JoystickGetDeviceGUID(int device_index); /// To be documented. - [NativeName("Src", "Line 242, Column 32 in SDL_joystick.h")] + [NativeName("Src", "Line 252, Column 32 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetDeviceVendor")] public partial ushort JoystickGetDeviceVendor(int device_index); /// To be documented. - [NativeName("Src", "Line 257, Column 32 in SDL_joystick.h")] + [NativeName("Src", "Line 267, Column 32 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetDeviceProduct")] public partial ushort JoystickGetDeviceProduct(int device_index); /// To be documented. - [NativeName("Src", "Line 272, Column 32 in SDL_joystick.h")] + [NativeName("Src", "Line 282, Column 32 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetDeviceProductVersion")] public partial ushort JoystickGetDeviceProductVersion(int device_index); /// To be documented. - [NativeName("Src", "Line 286, Column 42 in SDL_joystick.h")] + [NativeName("Src", "Line 296, Column 42 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetDeviceType")] public partial JoystickType JoystickGetDeviceType(int device_index); /// To be documented. - [NativeName("Src", "Line 300, Column 40 in SDL_joystick.h")] + [NativeName("Src", "Line 310, Column 40 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetDeviceInstanceID")] public partial int JoystickGetDeviceInstanceID(int device_index); /// To be documented. - [NativeName("Src", "Line 322, Column 39 in SDL_joystick.h")] + [NativeName("Src", "Line 332, Column 39 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickOpen")] public unsafe partial Joystick* JoystickOpen(int device_index); /// To be documented. - [NativeName("Src", "Line 333, Column 39 in SDL_joystick.h")] + [NativeName("Src", "Line 343, Column 39 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickFromInstanceID")] public unsafe partial Joystick* JoystickFromInstanceID(int instance_id); /// To be documented. - [NativeName("Src", "Line 344, Column 39 in SDL_joystick.h")] + [NativeName("Src", "Line 354, Column 39 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickFromPlayerIndex")] public unsafe partial Joystick* JoystickFromPlayerIndex(int player_index); /// To be documented. - [NativeName("Src", "Line 353, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 363, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickAttachVirtual")] public partial int JoystickAttachVirtual(JoystickType type, int naxes, int nbuttons, int nhats); /// To be documented. - [NativeName("Src", "Line 404, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 416, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickAttachVirtualEx")] public unsafe partial int JoystickAttachVirtualEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] VirtualJoystickDesc* desc); /// To be documented. - [NativeName("Src", "Line 404, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 416, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickAttachVirtualEx")] public partial int JoystickAttachVirtualEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly VirtualJoystickDesc desc); /// To be documented. - [NativeName("Src", "Line 415, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 427, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickDetachVirtual")] public partial int JoystickDetachVirtual(int device_index); /// To be documented. - [NativeName("Src", "Line 425, Column 34 in SDL_joystick.h")] + [NativeName("Src", "Line 437, Column 34 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickIsVirtual")] public partial SdlBool JoystickIsVirtual(int device_index); /// To be documented. - [NativeName("Src", "Line 447, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 459, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickSetVirtualAxis")] public unsafe partial int JoystickSetVirtualAxis(Joystick* joystick, int axis, short value); /// To be documented. - [NativeName("Src", "Line 465, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 477, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickSetVirtualButton")] public unsafe partial int JoystickSetVirtualButton(Joystick* joystick, int button, byte value); /// To be documented. - [NativeName("Src", "Line 483, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 495, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickSetVirtualHat")] public unsafe partial int JoystickSetVirtualHat(Joystick* joystick, int hat, byte value); /// To be documented. - [NativeName("Src", "Line 497, Column 37 in SDL_joystick.h")] + [NativeName("Src", "Line 509, Column 37 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickName")] public unsafe partial byte* JoystickName(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 497, Column 37 in SDL_joystick.h")] + [NativeName("Src", "Line 509, Column 37 in SDL_joystick.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_JoystickName")] public unsafe partial string JoystickNameS(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 510, Column 37 in SDL_joystick.h")] + [NativeName("Src", "Line 522, Column 37 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickPath")] public unsafe partial byte* JoystickPath(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 510, Column 37 in SDL_joystick.h")] + [NativeName("Src", "Line 522, Column 37 in SDL_joystick.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_JoystickPath")] public unsafe partial string JoystickPathS(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 523, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 535, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetPlayerIndex")] public unsafe partial int JoystickGetPlayerIndex(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 534, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 546, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickSetPlayerIndex")] public unsafe partial void JoystickSetPlayerIndex(Joystick* joystick, int player_index); /// To be documented. - [NativeName("Src", "Line 551, Column 42 in SDL_joystick.h")] + [NativeName("Src", "Line 563, Column 42 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetGUID")] - public unsafe partial GUID JoystickGetGUID(Joystick* joystick); + public unsafe partial Guid JoystickGetGUID(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 563, Column 32 in SDL_joystick.h")] + [NativeName("Src", "Line 575, Column 32 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetVendor")] public unsafe partial ushort JoystickGetVendor(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 575, Column 32 in SDL_joystick.h")] + [NativeName("Src", "Line 587, Column 32 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetProduct")] public unsafe partial ushort JoystickGetProduct(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 587, Column 32 in SDL_joystick.h")] + [NativeName("Src", "Line 599, Column 32 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetProductVersion")] public unsafe partial ushort JoystickGetProductVersion(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 600, Column 32 in SDL_joystick.h")] + [NativeName("Src", "Line 612, Column 32 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetFirmwareVersion")] public unsafe partial ushort JoystickGetFirmwareVersion(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 613, Column 38 in SDL_joystick.h")] + [NativeName("Src", "Line 625, Column 38 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetSerial")] public unsafe partial byte* JoystickGetSerial(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 613, Column 38 in SDL_joystick.h")] + [NativeName("Src", "Line 625, Column 38 in SDL_joystick.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_JoystickGetSerial")] public unsafe partial string JoystickGetSerialS(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 623, Column 42 in SDL_joystick.h")] + [NativeName("Src", "Line 635, Column 42 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetType")] public unsafe partial JoystickType JoystickGetType(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 640, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 652, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetGUIDString")] - public unsafe partial void JoystickGetGUIDString(GUID guid, byte* pszGUID, int cbGUID); + public unsafe partial void JoystickGetGUIDString(Guid guid, byte* pszGUID, int cbGUID); /// To be documented. - [NativeName("Src", "Line 640, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 652, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetGUIDString")] - public partial void JoystickGetGUIDString(GUID guid, ref byte pszGUID, int cbGUID); + public partial void JoystickGetGUIDString(Guid guid, ref byte pszGUID, int cbGUID); /// To be documented. - [NativeName("Src", "Line 640, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 652, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetGUIDString")] - public partial void JoystickGetGUIDString(GUID guid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszGUID, int cbGUID); + public partial void JoystickGetGUIDString(Guid guid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszGUID, int cbGUID); /// To be documented. - [NativeName("Src", "Line 656, Column 42 in SDL_joystick.h")] + [NativeName("Src", "Line 668, Column 42 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetGUIDFromString")] - public unsafe partial GUID JoystickGetGUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pchGUID); + public unsafe partial Guid JoystickGetGUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pchGUID); /// To be documented. - [NativeName("Src", "Line 656, Column 42 in SDL_joystick.h")] + [NativeName("Src", "Line 668, Column 42 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetGUIDFromString")] - public partial GUID JoystickGetGUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte pchGUID); + public partial Guid JoystickGetGUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte pchGUID); /// To be documented. - [NativeName("Src", "Line 656, Column 42 in SDL_joystick.h")] + [NativeName("Src", "Line 668, Column 42 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetGUIDFromString")] - public partial GUID JoystickGetGUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pchGUID); + public partial Guid JoystickGetGUIDFromString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pchGUID); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ushort* vendor, ushort* product, ushort* version, ushort* crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ushort* vendor, ushort* product, ushort* version, ushort* crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ushort* vendor, ushort* product, ushort* version, ref ushort crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ushort* vendor, ushort* product, ushort* version, ref ushort crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ushort* vendor, ushort* product, ref ushort version, ushort* crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ushort* vendor, ushort* product, ref ushort version, ushort* crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ushort* vendor, ushort* product, ref ushort version, ref ushort crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ushort* vendor, ushort* product, ref ushort version, ref ushort crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ushort* vendor, ref ushort product, ushort* version, ushort* crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ushort* vendor, ref ushort product, ushort* version, ushort* crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ushort* vendor, ref ushort product, ushort* version, ref ushort crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ushort* vendor, ref ushort product, ushort* version, ref ushort crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ushort* vendor, ref ushort product, ref ushort version, ushort* crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ushort* vendor, ref ushort product, ref ushort version, ushort* crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ushort* vendor, ref ushort product, ref ushort version, ref ushort crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ushort* vendor, ref ushort product, ref ushort version, ref ushort crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ref ushort vendor, ushort* product, ushort* version, ushort* crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ref ushort vendor, ushort* product, ushort* version, ushort* crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ref ushort vendor, ushort* product, ushort* version, ref ushort crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ref ushort vendor, ushort* product, ushort* version, ref ushort crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ref ushort vendor, ushort* product, ref ushort version, ushort* crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ref ushort vendor, ushort* product, ref ushort version, ushort* crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ref ushort vendor, ushort* product, ref ushort version, ref ushort crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ref ushort vendor, ushort* product, ref ushort version, ref ushort crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ref ushort vendor, ref ushort product, ushort* version, ushort* crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ref ushort vendor, ref ushort product, ushort* version, ushort* crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ref ushort vendor, ref ushort product, ushort* version, ref ushort crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ref ushort vendor, ref ushort product, ushort* version, ref ushort crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public unsafe partial void GetJoystickGUIDInfo(GUID guid, ref ushort vendor, ref ushort product, ref ushort version, ushort* crc16); + public unsafe partial void GetJoystickGUIDInfo(Guid guid, ref ushort vendor, ref ushort product, ref ushort version, ushort* crc16); /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_GetJoystickGUIDInfo")] - public partial void GetJoystickGUIDInfo(GUID guid, ref ushort vendor, ref ushort product, ref ushort version, ref ushort crc16); + public partial void GetJoystickGUIDInfo(Guid guid, ref ushort vendor, ref ushort product, ref ushort version, ref ushort crc16); /// To be documented. - [NativeName("Src", "Line 689, Column 34 in SDL_joystick.h")] + [NativeName("Src", "Line 701, Column 34 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetAttached")] public unsafe partial SdlBool JoystickGetAttached(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 702, Column 40 in SDL_joystick.h")] + [NativeName("Src", "Line 714, Column 40 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickInstanceID")] public unsafe partial int JoystickInstanceID(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 721, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 733, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickNumAxes")] public unsafe partial int JoystickNumAxes(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 739, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 751, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickNumBalls")] public unsafe partial int JoystickNumBalls(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 753, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 765, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickNumHats")] public unsafe partial int JoystickNumHats(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 767, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 779, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickNumButtons")] public unsafe partial int JoystickNumButtons(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 779, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 791, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickUpdate")] public partial void JoystickUpdate(); /// To be documented. - [NativeName("Src", "Line 809, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 821, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickEventState")] public partial int JoystickEventState(int state); /// To be documented. - [NativeName("Src", "Line 836, Column 32 in SDL_joystick.h")] + [NativeName("Src", "Line 849, Column 32 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetAxis")] public unsafe partial short JoystickGetAxis(Joystick* joystick, int axis); /// To be documented. - [NativeName("Src", "Line 853, Column 34 in SDL_joystick.h")] + [NativeName("Src", "Line 866, Column 34 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetAxisInitialState")] public unsafe partial SdlBool JoystickGetAxisInitialState(Joystick* joystick, int axis, short* state); /// To be documented. - [NativeName("Src", "Line 853, Column 34 in SDL_joystick.h")] + [NativeName("Src", "Line 866, Column 34 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetAxisInitialState")] public unsafe partial SdlBool JoystickGetAxisInitialState(Joystick* joystick, int axis, ref short state); /// To be documented. - [NativeName("Src", "Line 894, Column 31 in SDL_joystick.h")] + [NativeName("Src", "Line 907, Column 31 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetHat")] public unsafe partial byte JoystickGetHat(Joystick* joystick, int hat); /// To be documented. - [NativeName("Src", "Line 916, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 929, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetBall")] public unsafe partial int JoystickGetBall(Joystick* joystick, int ball, int* dx, int* dy); /// To be documented. - [NativeName("Src", "Line 916, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 929, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetBall")] public unsafe partial int JoystickGetBall(Joystick* joystick, int ball, int* dx, ref int dy); /// To be documented. - [NativeName("Src", "Line 916, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 929, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetBall")] public unsafe partial int JoystickGetBall(Joystick* joystick, int ball, ref int dx, int* dy); /// To be documented. - [NativeName("Src", "Line 916, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 929, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetBall")] public unsafe partial int JoystickGetBall(Joystick* joystick, int ball, ref int dx, ref int dy); /// To be documented. - [NativeName("Src", "Line 931, Column 31 in SDL_joystick.h")] + [NativeName("Src", "Line 944, Column 31 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickGetButton")] public unsafe partial byte JoystickGetButton(Joystick* joystick, int button); /// To be documented. - [NativeName("Src", "Line 952, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 965, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickRumble")] public unsafe partial int JoystickRumble(Joystick* joystick, ushort low_frequency_rumble, ushort high_frequency_rumble, uint duration_ms); /// To be documented. - [NativeName("Src", "Line 977, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 990, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickRumbleTriggers")] public unsafe partial int JoystickRumbleTriggers(Joystick* joystick, ushort left_rumble, ushort right_rumble, uint duration_ms); /// To be documented. - [NativeName("Src", "Line 990, Column 34 in SDL_joystick.h")] + [NativeName("Src", "Line 1003, Column 34 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickHasLED")] public unsafe partial SdlBool JoystickHasLED(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 1002, Column 34 in SDL_joystick.h")] + [NativeName("Src", "Line 1015, Column 34 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickHasRumble")] public unsafe partial SdlBool JoystickHasRumble(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 1014, Column 34 in SDL_joystick.h")] + [NativeName("Src", "Line 1027, Column 34 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickHasRumbleTriggers")] public unsafe partial SdlBool JoystickHasRumbleTriggers(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 1030, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 1043, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickSetLED")] public unsafe partial int JoystickSetLED(Joystick* joystick, byte red, byte green, byte blue); /// To be documented. - [NativeName("Src", "Line 1042, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 1056, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickSendEffect")] public unsafe partial int JoystickSendEffect(Joystick* joystick, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, int size); /// To be documented. - [NativeName("Src", "Line 1042, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 1056, Column 29 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickSendEffect")] public unsafe partial int JoystickSendEffect(Joystick* joystick, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, int size) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1053, Column 30 in SDL_joystick.h")] + [NativeName("Src", "Line 1067, Column 30 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickClose")] public unsafe partial void JoystickClose(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 1064, Column 48 in SDL_joystick.h")] + [NativeName("Src", "Line 1078, Column 48 in SDL_joystick.h")] [NativeApi(EntryPoint = "SDL_JoystickCurrentPowerLevel")] public unsafe partial JoystickPowerLevel JoystickCurrentPowerLevel(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 143, Column 30 in SDL_sensor.h")] + [NativeName("Src", "Line 150, Column 30 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_LockSensors")] public partial void LockSensors(); /// To be documented. - [NativeName("Src", "Line 144, Column 30 in SDL_sensor.h")] + [NativeName("Src", "Line 151, Column 30 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_UnlockSensors")] public partial void UnlockSensors(); /// To be documented. - [NativeName("Src", "Line 153, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 160, Column 29 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_NumSensors")] public partial int NumSensors(); /// To be documented. - [NativeName("Src", "Line 163, Column 37 in SDL_sensor.h")] + [NativeName("Src", "Line 170, Column 37 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetDeviceName")] public unsafe partial byte* SensorGetDeviceName(int device_index); /// To be documented. - [NativeName("Src", "Line 163, Column 37 in SDL_sensor.h")] + [NativeName("Src", "Line 170, Column 37 in SDL_sensor.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_SensorGetDeviceName")] public partial string SensorGetDeviceNameS(int device_index); /// To be documented. - [NativeName("Src", "Line 174, Column 40 in SDL_sensor.h")] + [NativeName("Src", "Line 181, Column 40 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetDeviceType")] public partial SensorType SensorGetDeviceType(int device_index); /// To be documented. - [NativeName("Src", "Line 185, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 192, Column 29 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetDeviceNonPortableType")] public partial int SensorGetDeviceNonPortableType(int device_index); /// To be documented. - [NativeName("Src", "Line 195, Column 38 in SDL_sensor.h")] + [NativeName("Src", "Line 202, Column 38 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetDeviceInstanceID")] public partial int SensorGetDeviceInstanceID(int device_index); /// To be documented. - [NativeName("Src", "Line 205, Column 37 in SDL_sensor.h")] + [NativeName("Src", "Line 212, Column 37 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorOpen")] public unsafe partial Sensor* SensorOpen(int device_index); /// To be documented. - [NativeName("Src", "Line 215, Column 37 in SDL_sensor.h")] + [NativeName("Src", "Line 222, Column 37 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorFromInstanceID")] public unsafe partial Sensor* SensorFromInstanceID(int instance_id); /// To be documented. - [NativeName("Src", "Line 225, Column 37 in SDL_sensor.h")] + [NativeName("Src", "Line 232, Column 37 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetName")] public unsafe partial byte* SensorGetName(Sensor* sensor); /// To be documented. - [NativeName("Src", "Line 225, Column 37 in SDL_sensor.h")] + [NativeName("Src", "Line 232, Column 37 in SDL_sensor.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_SensorGetName")] public unsafe partial string SensorGetNameS(Sensor* sensor); /// To be documented. - [NativeName("Src", "Line 236, Column 40 in SDL_sensor.h")] + [NativeName("Src", "Line 243, Column 40 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetType")] public unsafe partial SensorType SensorGetType(Sensor* sensor); /// To be documented. - [NativeName("Src", "Line 246, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 253, Column 29 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetNonPortableType")] public unsafe partial int SensorGetNonPortableType(Sensor* sensor); /// To be documented. - [NativeName("Src", "Line 256, Column 38 in SDL_sensor.h")] + [NativeName("Src", "Line 263, Column 38 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetInstanceID")] public unsafe partial int SensorGetInstanceID(Sensor* sensor); /// To be documented. - [NativeName("Src", "Line 270, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 277, Column 29 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetData")] public unsafe partial int SensorGetData(Sensor* sensor, float* data, int num_values); /// To be documented. - [NativeName("Src", "Line 270, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 277, Column 29 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetData")] public unsafe partial int SensorGetData(Sensor* sensor, ref float data, int num_values); /// To be documented. - [NativeName("Src", "Line 287, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 294, Column 29 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetDataWithTimestamp")] public unsafe partial int SensorGetDataWithTimestamp(Sensor* sensor, ulong* timestamp, float* data, int num_values); /// To be documented. - [NativeName("Src", "Line 287, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 294, Column 29 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetDataWithTimestamp")] public unsafe partial int SensorGetDataWithTimestamp(Sensor* sensor, ulong* timestamp, ref float data, int num_values); /// To be documented. - [NativeName("Src", "Line 287, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 294, Column 29 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetDataWithTimestamp")] public unsafe partial int SensorGetDataWithTimestamp(Sensor* sensor, ref ulong timestamp, float* data, int num_values); /// To be documented. - [NativeName("Src", "Line 287, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 294, Column 29 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorGetDataWithTimestamp")] public unsafe partial int SensorGetDataWithTimestamp(Sensor* sensor, ref ulong timestamp, ref float data, int num_values); /// To be documented. - [NativeName("Src", "Line 296, Column 30 in SDL_sensor.h")] + [NativeName("Src", "Line 303, Column 30 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorClose")] public unsafe partial void SensorClose(Sensor* sensor); /// To be documented. - [NativeName("Src", "Line 309, Column 30 in SDL_sensor.h")] + [NativeName("Src", "Line 316, Column 30 in SDL_sensor.h")] [NativeApi(EntryPoint = "SDL_SensorUpdate")] public partial void SensorUpdate(); /// To be documented. - [NativeName("Src", "Line 166, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 173, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerAddMappingsFromRW")] public unsafe partial int GameControllerAddMappingsFromRW(RWops* rw, int freerw); /// To be documented. - [NativeName("Src", "Line 166, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 173, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerAddMappingsFromRW")] public partial int GameControllerAddMappingsFromRW(ref RWops rw, int freerw); /// To be documented. - [NativeName("Src", "Line 202, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 215, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerAddMapping")] public unsafe partial int GameControllerAddMapping([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* mappingString); /// To be documented. - [NativeName("Src", "Line 202, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 215, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerAddMapping")] public partial int GameControllerAddMapping([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte mappingString); /// To be documented. - [NativeName("Src", "Line 202, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 215, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerAddMapping")] public partial int GameControllerAddMapping([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string mappingString); /// To be documented. - [NativeName("Src", "Line 211, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 224, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerNumMappings")] public partial int GameControllerNumMappings(); /// To be documented. - [NativeName("Src", "Line 221, Column 32 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 234, Column 32 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerMappingForIndex")] public unsafe partial byte* GameControllerMappingForIndex(int mapping_index); /// To be documented. - [NativeName("Src", "Line 221, Column 32 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 234, Column 32 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerMappingForIndex")] public partial string GameControllerMappingForIndexS(int mapping_index); /// To be documented. - [NativeName("Src", "Line 237, Column 32 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 250, Column 32 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerMappingForGUID")] - public unsafe partial byte* GameControllerMappingForGUID(GUID guid); + public unsafe partial byte* GameControllerMappingForGUID(Guid guid); /// To be documented. - [NativeName("Src", "Line 237, Column 32 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 250, Column 32 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerMappingForGUID")] - public partial string GameControllerMappingForGUIDS(GUID guid); + public partial string GameControllerMappingForGUIDS(Guid guid); /// To be documented. - [NativeName("Src", "Line 256, Column 32 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 269, Column 32 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerMapping")] public unsafe partial byte* GameControllerMapping(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 256, Column 32 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 269, Column 32 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerMapping")] public unsafe partial string GameControllerMappingS(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 274, Column 34 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 287, Column 34 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_IsGameController")] public partial SdlBool IsGameController(int joystick_index); /// To be documented. - [NativeName("Src", "Line 295, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 308, Column 37 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerNameForIndex")] public unsafe partial byte* GameControllerNameForIndex(int joystick_index); /// To be documented. - [NativeName("Src", "Line 295, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 308, Column 37 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerNameForIndex")] public partial string GameControllerNameForIndexS(int joystick_index); /// To be documented. - [NativeName("Src", "Line 314, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 327, Column 37 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerPathForIndex")] public unsafe partial byte* GameControllerPathForIndex(int joystick_index); /// To be documented. - [NativeName("Src", "Line 314, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 327, Column 37 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerPathForIndex")] public partial string GameControllerPathForIndexS(int joystick_index); /// To be documented. - [NativeName("Src", "Line 327, Column 48 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 340, Column 48 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerTypeForIndex")] public partial GameControllerType GameControllerTypeForIndex(int joystick_index); /// To be documented. - [NativeName("Src", "Line 341, Column 31 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 354, Column 31 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerMappingForDeviceIndex")] public unsafe partial byte* GameControllerMappingForDeviceIndex(int joystick_index); /// To be documented. - [NativeName("Src", "Line 341, Column 31 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 354, Column 31 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerMappingForDeviceIndex")] public partial string GameControllerMappingForDeviceIndexS(int joystick_index); /// To be documented. - [NativeName("Src", "Line 365, Column 45 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 378, Column 45 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerOpen")] public unsafe partial GameController* GameControllerOpen(int joystick_index); /// To be documented. - [NativeName("Src", "Line 376, Column 45 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 389, Column 45 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerFromInstanceID")] public unsafe partial GameController* GameControllerFromInstanceID(int joyid); /// To be documented. - [NativeName("Src", "Line 393, Column 45 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 406, Column 45 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerFromPlayerIndex")] public unsafe partial GameController* GameControllerFromPlayerIndex(int player_index); /// To be documented. - [NativeName("Src", "Line 411, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 424, Column 37 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerName")] public unsafe partial byte* GameControllerName(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 411, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 424, Column 37 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerName")] public unsafe partial string GameControllerNameS(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 428, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 441, Column 37 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerPath")] public unsafe partial byte* GameControllerPath(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 428, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 441, Column 37 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerPath")] public unsafe partial string GameControllerPathS(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 441, Column 48 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 454, Column 48 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetType")] public unsafe partial GameControllerType GameControllerGetType(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 453, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 466, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetPlayerIndex")] public unsafe partial int GameControllerGetPlayerIndex(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 464, Column 30 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 477, Column 30 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerSetPlayerIndex")] public unsafe partial void GameControllerSetPlayerIndex(GameController* gamecontroller, int player_index); /// To be documented. - [NativeName("Src", "Line 476, Column 32 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 489, Column 32 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetVendor")] public unsafe partial ushort GameControllerGetVendor(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 488, Column 32 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 501, Column 32 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetProduct")] public unsafe partial ushort GameControllerGetProduct(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 500, Column 32 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 513, Column 32 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetProductVersion")] public unsafe partial ushort GameControllerGetProductVersion(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 512, Column 32 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 525, Column 32 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetFirmwareVersion")] public unsafe partial ushort GameControllerGetFirmwareVersion(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 525, Column 38 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 538, Column 38 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetSerial")] public unsafe partial byte* GameControllerGetSerial(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 525, Column 38 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 538, Column 38 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerGetSerial")] public unsafe partial string GameControllerGetSerialS(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 538, Column 32 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 551, Column 32 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetSteamHandle")] public unsafe partial ulong GameControllerGetSteamHandle(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 554, Column 34 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 567, Column 34 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetAttached")] public unsafe partial SdlBool GameControllerGetAttached(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 575, Column 39 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 588, Column 39 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetJoystick")] public unsafe partial Joystick* GameControllerGetJoystick(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 595, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 608, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerEventState")] public partial int GameControllerEventState(int state); /// To be documented. - [NativeName("Src", "Line 606, Column 30 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 619, Column 30 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerUpdate")] public partial void GameControllerUpdate(); /// To be documented. - [NativeName("Src", "Line 652, Column 48 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 667, Column 48 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetAxisFromString")] public unsafe partial GameControllerAxis GameControllerGetAxisFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str); /// To be documented. - [NativeName("Src", "Line 652, Column 48 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 667, Column 48 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetAxisFromString")] public partial GameControllerAxis GameControllerGetAxisFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str); /// To be documented. - [NativeName("Src", "Line 652, Column 48 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 667, Column 48 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetAxisFromString")] public partial GameControllerAxis GameControllerGetAxisFromString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 668, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 683, Column 37 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetStringForAxis")] public unsafe partial byte* GameControllerGetStringForAxis(GameControllerAxis axis); /// To be documented. - [NativeName("Src", "Line 668, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 683, Column 37 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerGetStringForAxis")] public partial string GameControllerGetStringForAxisS(GameControllerAxis axis); /// To be documented. - [NativeName("Src", "Line 684, Column 1 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 699, Column 1 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetBindForAxis")] public unsafe partial GameControllerButtonBind GameControllerGetBindForAxis(GameController* gamecontroller, GameControllerAxis axis); /// To be documented. - [NativeName("Src", "Line 700, Column 1 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 715, Column 1 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerHasAxis")] public unsafe partial SdlBool GameControllerHasAxis(GameController* gamecontroller, GameControllerAxis axis); /// To be documented. - [NativeName("Src", "Line 725, Column 1 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 739, Column 1 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetAxis")] public unsafe partial short GameControllerGetAxis(GameController* gamecontroller, GameControllerAxis axis); /// To be documented. - [NativeName("Src", "Line 771, Column 50 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 785, Column 50 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetButtonFromString")] public unsafe partial GameControllerButton GameControllerGetButtonFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str); /// To be documented. - [NativeName("Src", "Line 771, Column 50 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 785, Column 50 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetButtonFromString")] public partial GameControllerButton GameControllerGetButtonFromString([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str); /// To be documented. - [NativeName("Src", "Line 771, Column 50 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 785, Column 50 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetButtonFromString")] public partial GameControllerButton GameControllerGetButtonFromString([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str); /// To be documented. - [NativeName("Src", "Line 787, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 801, Column 37 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetStringForButton")] public unsafe partial byte* GameControllerGetStringForButton(GameControllerButton button); /// To be documented. - [NativeName("Src", "Line 787, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 801, Column 37 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerGetStringForButton")] public partial string GameControllerGetStringForButtonS(GameControllerButton button); /// To be documented. - [NativeName("Src", "Line 803, Column 1 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 817, Column 1 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetBindForButton")] public unsafe partial GameControllerButtonBind GameControllerGetBindForButton(GameController* gamecontroller, GameControllerButton button); /// To be documented. - [NativeName("Src", "Line 818, Column 34 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 832, Column 34 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerHasButton")] public unsafe partial SdlBool GameControllerHasButton(GameController* gamecontroller, GameControllerButton button); /// To be documented. - [NativeName("Src", "Line 833, Column 31 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 847, Column 31 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetButton")] public unsafe partial byte GameControllerGetButton(GameController* gamecontroller, GameControllerButton button); /// To be documented. - [NativeName("Src", "Line 841, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 855, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetNumTouchpads")] public unsafe partial int GameControllerGetNumTouchpads(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 849, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 863, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetNumTouchpadFingers")] public unsafe partial int GameControllerGetNumTouchpadFingers(GameController* gamecontroller, int touchpad); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, byte* state, float* x, float* y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, byte* state, float* x, float* y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, byte* state, float* x, ref float y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, byte* state, float* x, ref float y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, byte* state, ref float x, float* y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, byte* state, ref float x, float* y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, byte* state, ref float x, ref float y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, byte* state, ref float x, ref float y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, ref byte state, float* x, float* y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, ref byte state, float* x, float* y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, ref byte state, float* x, ref float y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, ref byte state, float* x, ref float y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, ref byte state, ref float x, float* y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, ref byte state, ref float x, float* y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, ref byte state, ref float x, ref float y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, ref byte state, ref float x, ref float y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, float* x, float* y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, float* x, float* y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, float* x, ref float y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, float* x, ref float y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, ref float x, float* y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, ref float x, float* y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, ref float x, ref float y, float* pressure); /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetTouchpadFinger")] public unsafe partial int GameControllerGetTouchpadFinger(GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, ref float x, ref float y, ref float pressure); /// To be documented. - [NativeName("Src", "Line 867, Column 34 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 881, Column 34 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerHasSensor")] public unsafe partial SdlBool GameControllerHasSensor(GameController* gamecontroller, SensorType type); /// To be documented. - [NativeName("Src", "Line 879, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 893, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerSetSensorEnabled")] public unsafe partial int GameControllerSetSensorEnabled(GameController* gamecontroller, SensorType type, SdlBool enabled); /// To be documented. - [NativeName("Src", "Line 890, Column 34 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 904, Column 34 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerIsSensorEnabled")] public unsafe partial SdlBool GameControllerIsSensorEnabled(GameController* gamecontroller, SensorType type); /// To be documented. - [NativeName("Src", "Line 902, Column 31 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 916, Column 31 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetSensorDataRate")] public unsafe partial float GameControllerGetSensorDataRate(GameController* gamecontroller, SensorType type); /// To be documented. - [NativeName("Src", "Line 918, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 932, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetSensorData")] public unsafe partial int GameControllerGetSensorData(GameController* gamecontroller, SensorType type, float* data, int num_values); /// To be documented. - [NativeName("Src", "Line 918, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 932, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetSensorData")] public unsafe partial int GameControllerGetSensorData(GameController* gamecontroller, SensorType type, ref float data, int num_values); /// To be documented. - [NativeName("Src", "Line 937, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 951, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetSensorDataWithTimestamp")] public unsafe partial int GameControllerGetSensorDataWithTimestamp(GameController* gamecontroller, SensorType type, ulong* timestamp, float* data, int num_values); /// To be documented. - [NativeName("Src", "Line 937, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 951, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetSensorDataWithTimestamp")] public unsafe partial int GameControllerGetSensorDataWithTimestamp(GameController* gamecontroller, SensorType type, ulong* timestamp, ref float data, int num_values); /// To be documented. - [NativeName("Src", "Line 937, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 951, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetSensorDataWithTimestamp")] public unsafe partial int GameControllerGetSensorDataWithTimestamp(GameController* gamecontroller, SensorType type, ref ulong timestamp, float* data, int num_values); /// To be documented. - [NativeName("Src", "Line 937, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 951, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetSensorDataWithTimestamp")] public unsafe partial int GameControllerGetSensorDataWithTimestamp(GameController* gamecontroller, SensorType type, ref ulong timestamp, ref float data, int num_values); /// To be documented. - [NativeName("Src", "Line 957, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 971, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerRumble")] public unsafe partial int GameControllerRumble(GameController* gamecontroller, ushort low_frequency_rumble, ushort high_frequency_rumble, uint duration_ms); /// To be documented. - [NativeName("Src", "Line 982, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 996, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerRumbleTriggers")] public unsafe partial int GameControllerRumbleTriggers(GameController* gamecontroller, ushort left_rumble, ushort right_rumble, uint duration_ms); /// To be documented. - [NativeName("Src", "Line 993, Column 34 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1007, Column 34 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerHasLED")] public unsafe partial SdlBool GameControllerHasLED(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 1006, Column 34 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1020, Column 34 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerHasRumble")] public unsafe partial SdlBool GameControllerHasRumble(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 1019, Column 34 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1033, Column 34 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerHasRumbleTriggers")] public unsafe partial SdlBool GameControllerHasRumbleTriggers(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 1032, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1046, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerSetLED")] public unsafe partial int GameControllerSetLED(GameController* gamecontroller, byte red, byte green, byte blue); /// To be documented. - [NativeName("Src", "Line 1045, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1059, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerSendEffect")] public unsafe partial int GameControllerSendEffect(GameController* gamecontroller, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* data, int size); /// To be documented. - [NativeName("Src", "Line 1045, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1059, Column 29 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerSendEffect")] public unsafe partial int GameControllerSendEffect(GameController* gamecontroller, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 data, int size) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1057, Column 30 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1071, Column 30 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerClose")] public unsafe partial void GameControllerClose(GameController* gamecontroller); /// To be documented. - [NativeName("Src", "Line 1071, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1085, Column 37 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetAppleSFSymbolsNameForButton")] public unsafe partial byte* GameControllerGetAppleSFSymbolsNameForButton(GameController* gamecontroller, GameControllerButton button); /// To be documented. - [NativeName("Src", "Line 1071, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1085, Column 37 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerGetAppleSFSymbolsNameForButton")] public unsafe partial string GameControllerGetAppleSFSymbolsNameForButtonS(GameController* gamecontroller, GameControllerButton button); /// To be documented. - [NativeName("Src", "Line 1085, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1099, Column 37 in SDL_gamecontroller.h")] [NativeApi(EntryPoint = "SDL_GameControllerGetAppleSFSymbolsNameForAxis")] public unsafe partial byte* GameControllerGetAppleSFSymbolsNameForAxis(GameController* gamecontroller, GameControllerAxis axis); /// To be documented. - [NativeName("Src", "Line 1085, Column 37 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1099, Column 37 in SDL_gamecontroller.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GameControllerGetAppleSFSymbolsNameForAxis")] public unsafe partial string GameControllerGetAppleSFSymbolsNameForAxisS(GameController* gamecontroller, GameControllerAxis axis); @@ -11456,147 +11459,147 @@ public unsafe partial class Sdl : NativeAPI public partial int LoadDollarTemplates(long touchId, ref RWops src); /// To be documented. - [NativeName("Src", "Line 696, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 733, Column 30 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_PumpEvents")] public partial void PumpEvents(); /// To be documented. - [NativeName("Src", "Line 744, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 781, Column 29 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_PeepEvents")] public unsafe partial int PeepEvents(Event* events, int numevents, Eventaction action, uint minType, uint maxType); /// To be documented. - [NativeName("Src", "Line 744, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 781, Column 29 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_PeepEvents")] public partial int PeepEvents(ref Event events, int numevents, Eventaction action, uint minType, uint maxType); /// To be documented. - [NativeName("Src", "Line 763, Column 34 in SDL_events.h")] + [NativeName("Src", "Line 800, Column 34 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_HasEvent")] public partial SdlBool HasEvent(uint type); /// To be documented. - [NativeName("Src", "Line 782, Column 34 in SDL_events.h")] + [NativeName("Src", "Line 819, Column 34 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_HasEvents")] public partial SdlBool HasEvents(uint minType, uint maxType); /// To be documented. - [NativeName("Src", "Line 804, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 841, Column 30 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_FlushEvent")] public partial void FlushEvent(uint type); /// To be documented. - [NativeName("Src", "Line 829, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 866, Column 30 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_FlushEvents")] public partial void FlushEvents(uint minType, uint maxType); /// To be documented. - [NativeName("Src", "Line 876, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 913, Column 29 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_PollEvent")] public unsafe partial int PollEvent(Event* @event); /// To be documented. - [NativeName("Src", "Line 876, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 913, Column 29 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_PollEvent")] public partial int PollEvent(ref Event @event); /// To be documented. - [NativeName("Src", "Line 898, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 935, Column 29 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_WaitEvent")] public unsafe partial int WaitEvent(Event* @event); /// To be documented. - [NativeName("Src", "Line 898, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 935, Column 29 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_WaitEvent")] public partial int WaitEvent(ref Event @event); /// To be documented. - [NativeName("Src", "Line 924, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 961, Column 29 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_WaitEventTimeout")] public unsafe partial int WaitEventTimeout(Event* @event, int timeout); /// To be documented. - [NativeName("Src", "Line 924, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 961, Column 29 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_WaitEventTimeout")] public partial int WaitEventTimeout(ref Event @event, int timeout); /// To be documented. - [NativeName("Src", "Line 959, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 996, Column 29 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_PushEvent")] public unsafe partial int PushEvent(Event* @event); /// To be documented. - [NativeName("Src", "Line 959, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 996, Column 29 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_PushEvent")] public partial int PushEvent(ref Event @event); /// To be documented. - [NativeName("Src", "Line 1017, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1054, Column 30 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_SetEventFilter")] public unsafe partial void SetEventFilter(PfnEventFilter filter, void* userdata); /// To be documented. - [NativeName("Src", "Line 1017, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1054, Column 30 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_SetEventFilter")] public partial void SetEventFilter(PfnEventFilter filter, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1035, Column 34 in SDL_events.h")] + [NativeName("Src", "Line 1072, Column 34 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_GetEventFilter")] public unsafe partial SdlBool GetEventFilter(PfnEventFilter* filter, void** userdata); /// To be documented. - [NativeName("Src", "Line 1035, Column 34 in SDL_events.h")] + [NativeName("Src", "Line 1072, Column 34 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_GetEventFilter")] public unsafe partial SdlBool GetEventFilter(PfnEventFilter* filter, ref void* userdata); /// To be documented. - [NativeName("Src", "Line 1035, Column 34 in SDL_events.h")] + [NativeName("Src", "Line 1072, Column 34 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_GetEventFilter")] public unsafe partial SdlBool GetEventFilter(ref PfnEventFilter filter, void** userdata); /// To be documented. - [NativeName("Src", "Line 1035, Column 34 in SDL_events.h")] + [NativeName("Src", "Line 1072, Column 34 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_GetEventFilter")] public unsafe partial SdlBool GetEventFilter(ref PfnEventFilter filter, ref void* userdata); /// To be documented. - [NativeName("Src", "Line 1064, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1101, Column 30 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_AddEventWatch")] public unsafe partial void AddEventWatch(PfnEventFilter filter, void* userdata); /// To be documented. - [NativeName("Src", "Line 1064, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1101, Column 30 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_AddEventWatch")] public partial void AddEventWatch(PfnEventFilter filter, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1080, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1117, Column 30 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_DelEventWatch")] public unsafe partial void DelEventWatch(PfnEventFilter filter, void* userdata); /// To be documented. - [NativeName("Src", "Line 1080, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1117, Column 30 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_DelEventWatch")] public partial void DelEventWatch(PfnEventFilter filter, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1099, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1136, Column 30 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_FilterEvents")] public unsafe partial void FilterEvents(PfnEventFilter filter, void* userdata); /// To be documented. - [NativeName("Src", "Line 1099, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1136, Column 30 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_FilterEvents")] public partial void FilterEvents(PfnEventFilter filter, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1127, Column 31 in SDL_events.h")] + [NativeName("Src", "Line 1164, Column 31 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_EventState")] public partial byte EventState(uint type, int state); /// To be documented. - [NativeName("Src", "Line 1149, Column 32 in SDL_events.h")] + [NativeName("Src", "Line 1186, Column 32 in SDL_events.h")] [NativeApi(EntryPoint = "SDL_RegisterEvents")] public partial uint RegisterEvents(int numevents); @@ -11711,661 +11714,661 @@ public unsafe partial class Sdl : NativeAPI public partial string GetPrefPathS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string org, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string app); /// To be documented. - [NativeName("Src", "Line 834, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 846, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_NumHaptics")] public partial int NumHaptics(); /// To be documented. - [NativeName("Src", "Line 850, Column 37 in SDL_haptic.h")] + [NativeName("Src", "Line 862, Column 37 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticName")] public unsafe partial byte* HapticName(int device_index); /// To be documented. - [NativeName("Src", "Line 850, Column 37 in SDL_haptic.h")] + [NativeName("Src", "Line 862, Column 37 in SDL_haptic.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_HapticName")] public partial string HapticNameS(int device_index); /// To be documented. - [NativeName("Src", "Line 877, Column 37 in SDL_haptic.h")] + [NativeName("Src", "Line 889, Column 37 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticOpen")] public unsafe partial Haptic* HapticOpen(int device_index); /// To be documented. - [NativeName("Src", "Line 891, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 903, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticOpened")] public partial int HapticOpened(int device_index); /// To be documented. - [NativeName("Src", "Line 905, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 917, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticIndex")] public unsafe partial int HapticIndex(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 916, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 928, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_MouseIsHaptic")] public partial int MouseIsHaptic(); /// To be documented. - [NativeName("Src", "Line 929, Column 37 in SDL_haptic.h")] + [NativeName("Src", "Line 941, Column 37 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticOpenFromMouse")] public unsafe partial Haptic* HapticOpenFromMouse(); /// To be documented. - [NativeName("Src", "Line 943, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 955, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_JoystickIsHaptic")] public unsafe partial int JoystickIsHaptic(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 966, Column 37 in SDL_haptic.h")] + [NativeName("Src", "Line 978, Column 37 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticOpenFromJoystick")] public unsafe partial Haptic* HapticOpenFromJoystick(Joystick* joystick); /// To be documented. - [NativeName("Src", "Line 978, Column 30 in SDL_haptic.h")] + [NativeName("Src", "Line 990, Column 30 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticClose")] public unsafe partial void HapticClose(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 996, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1008, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticNumEffects")] public unsafe partial int HapticNumEffects(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 1013, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1025, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticNumEffectsPlaying")] public unsafe partial int HapticNumEffectsPlaying(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 1027, Column 38 in SDL_haptic.h")] + [NativeName("Src", "Line 1039, Column 38 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticQuery")] public unsafe partial uint HapticQuery(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 1042, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1054, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticNumAxes")] public unsafe partial int HapticNumAxes(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 1058, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1070, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticEffectSupported")] public unsafe partial int HapticEffectSupported(Haptic* haptic, HapticEffect* effect); /// To be documented. - [NativeName("Src", "Line 1058, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1070, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticEffectSupported")] public unsafe partial int HapticEffectSupported(Haptic* haptic, ref HapticEffect effect); /// To be documented. - [NativeName("Src", "Line 1077, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1089, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticNewEffect")] public unsafe partial int HapticNewEffect(Haptic* haptic, HapticEffect* effect); /// To be documented. - [NativeName("Src", "Line 1077, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1089, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticNewEffect")] public unsafe partial int HapticNewEffect(Haptic* haptic, ref HapticEffect effect); /// To be documented. - [NativeName("Src", "Line 1101, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1113, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticUpdateEffect")] public unsafe partial int HapticUpdateEffect(Haptic* haptic, int effect, HapticEffect* data); /// To be documented. - [NativeName("Src", "Line 1101, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1113, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticUpdateEffect")] public unsafe partial int HapticUpdateEffect(Haptic* haptic, int effect, ref HapticEffect data); /// To be documented. - [NativeName("Src", "Line 1127, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1139, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticRunEffect")] public unsafe partial int HapticRunEffect(Haptic* haptic, int effect, uint iterations); /// To be documented. - [NativeName("Src", "Line 1146, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1158, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticStopEffect")] public unsafe partial int HapticStopEffect(Haptic* haptic, int effect); /// To be documented. - [NativeName("Src", "Line 1162, Column 30 in SDL_haptic.h")] + [NativeName("Src", "Line 1174, Column 30 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticDestroyEffect")] public unsafe partial void HapticDestroyEffect(Haptic* haptic, int effect); /// To be documented. - [NativeName("Src", "Line 1180, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1192, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticGetEffectStatus")] public unsafe partial int HapticGetEffectStatus(Haptic* haptic, int effect); /// To be documented. - [NativeName("Src", "Line 1202, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1215, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticSetGain")] public unsafe partial int HapticSetGain(Haptic* haptic, int gain); /// To be documented. - [NativeName("Src", "Line 1221, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1234, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticSetAutocenter")] public unsafe partial int HapticSetAutocenter(Haptic* haptic, int autocenter); /// To be documented. - [NativeName("Src", "Line 1241, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1254, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticPause")] public unsafe partial int HapticPause(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 1256, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1269, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticUnpause")] public unsafe partial int HapticUnpause(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 1267, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1280, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticStopAll")] public unsafe partial int HapticStopAll(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 1283, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1296, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticRumbleSupported")] public unsafe partial int HapticRumbleSupported(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 1299, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1312, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticRumbleInit")] public unsafe partial int HapticRumbleInit(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 1316, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1329, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticRumblePlay")] public unsafe partial int HapticRumblePlay(Haptic* haptic, float strength, uint length); /// To be documented. - [NativeName("Src", "Line 1331, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1344, Column 29 in SDL_haptic.h")] [NativeApi(EntryPoint = "SDL_HapticRumbleStop")] public unsafe partial int HapticRumbleStop(Haptic* haptic); /// To be documented. - [NativeName("Src", "Line 142, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 134, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_init")] public partial int HidInit(); /// To be documented. - [NativeName("Src", "Line 156, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 148, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_exit")] public partial int HidExit(); /// To be documented. - [NativeName("Src", "Line 177, Column 32 in SDL_hidapi.h")] + [NativeName("Src", "Line 169, Column 32 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_device_change_count")] public partial uint HidDeviceChangeCount(); /// To be documented. - [NativeName("Src", "Line 199, Column 47 in SDL_hidapi.h")] + [NativeName("Src", "Line 191, Column 47 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_enumerate")] public unsafe partial HidDeviceInfo* HidEnumerate(ushort vendor_id, ushort product_id); /// To be documented. - [NativeName("Src", "Line 211, Column 30 in SDL_hidapi.h")] + [NativeName("Src", "Line 203, Column 30 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_free_enumeration")] public unsafe partial void HidFreeEnumeration(HidDeviceInfo* devs); /// To be documented. - [NativeName("Src", "Line 211, Column 30 in SDL_hidapi.h")] + [NativeName("Src", "Line 203, Column 30 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_free_enumeration")] public partial void HidFreeEnumeration(ref HidDeviceInfo devs); /// To be documented. - [NativeName("Src", "Line 229, Column 42 in SDL_hidapi.h")] + [NativeName("Src", "Line 221, Column 42 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_open")] public unsafe partial HidDevice* HidOpen(ushort vendor_id, ushort product_id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* serial_number); /// To be documented. - [NativeName("Src", "Line 229, Column 42 in SDL_hidapi.h")] + [NativeName("Src", "Line 221, Column 42 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_open")] public unsafe partial HidDevice* HidOpen(ushort vendor_id, ushort product_id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly char serial_number); /// To be documented. - [NativeName("Src", "Line 229, Column 42 in SDL_hidapi.h")] + [NativeName("Src", "Line 221, Column 42 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_open")] public unsafe partial HidDevice* HidOpen(ushort vendor_id, ushort product_id, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string serial_number); /// To be documented. - [NativeName("Src", "Line 243, Column 42 in SDL_hidapi.h")] + [NativeName("Src", "Line 235, Column 42 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_open_path")] public unsafe partial HidDevice* HidOpenPath([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* path, int bExclusive); /// To be documented. - [NativeName("Src", "Line 243, Column 42 in SDL_hidapi.h")] + [NativeName("Src", "Line 235, Column 42 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_open_path")] public unsafe partial HidDevice* HidOpenPath([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte path, int bExclusive); /// To be documented. - [NativeName("Src", "Line 243, Column 42 in SDL_hidapi.h")] + [NativeName("Src", "Line 235, Column 42 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_open_path")] public unsafe partial HidDevice* HidOpenPath([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string path, int bExclusive); /// To be documented. - [NativeName("Src", "Line 269, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 261, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_write")] public unsafe partial int HidWrite(HidDevice* dev, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* data, nuint length); /// To be documented. - [NativeName("Src", "Line 269, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 261, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_write")] public unsafe partial int HidWrite(HidDevice* dev, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte data, nuint length); /// To be documented. - [NativeName("Src", "Line 269, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 261, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_write")] public unsafe partial int HidWrite(HidDevice* dev, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string data, nuint length); /// To be documented. - [NativeName("Src", "Line 290, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 282, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_read_timeout")] public unsafe partial int HidReadTimeout(HidDevice* dev, byte* data, nuint length, int milliseconds); /// To be documented. - [NativeName("Src", "Line 290, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 282, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_read_timeout")] public unsafe partial int HidReadTimeout(HidDevice* dev, ref byte data, nuint length, int milliseconds); /// To be documented. - [NativeName("Src", "Line 290, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 282, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_read_timeout")] public unsafe partial int HidReadTimeout(HidDevice* dev, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string data, nuint length, int milliseconds); /// To be documented. - [NativeName("Src", "Line 310, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 302, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_read")] public unsafe partial int HidRead(HidDevice* dev, byte* data, nuint length); /// To be documented. - [NativeName("Src", "Line 310, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 302, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_read")] public unsafe partial int HidRead(HidDevice* dev, ref byte data, nuint length); /// To be documented. - [NativeName("Src", "Line 310, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 302, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_read")] public unsafe partial int HidRead(HidDevice* dev, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string data, nuint length); /// To be documented. - [NativeName("Src", "Line 328, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 320, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_set_nonblocking")] public unsafe partial int HidSetNonblocking(HidDevice* dev, int nonblock); /// To be documented. - [NativeName("Src", "Line 352, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 344, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_send_feature_report")] public unsafe partial int HidSendFeatureReport(HidDevice* dev, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* data, nuint length); /// To be documented. - [NativeName("Src", "Line 352, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 344, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_send_feature_report")] public unsafe partial int HidSendFeatureReport(HidDevice* dev, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte data, nuint length); /// To be documented. - [NativeName("Src", "Line 352, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 344, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_send_feature_report")] public unsafe partial int HidSendFeatureReport(HidDevice* dev, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string data, nuint length); /// To be documented. - [NativeName("Src", "Line 374, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 366, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_feature_report")] public unsafe partial int HidGetFeatureReport(HidDevice* dev, byte* data, nuint length); /// To be documented. - [NativeName("Src", "Line 374, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 366, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_feature_report")] public unsafe partial int HidGetFeatureReport(HidDevice* dev, ref byte data, nuint length); /// To be documented. - [NativeName("Src", "Line 374, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 366, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_feature_report")] public unsafe partial int HidGetFeatureReport(HidDevice* dev, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string data, nuint length); /// To be documented. - [NativeName("Src", "Line 383, Column 30 in SDL_hidapi.h")] + [NativeName("Src", "Line 375, Column 30 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_close")] public unsafe partial void HidClose(HidDevice* dev); /// To be documented. - [NativeName("Src", "Line 395, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_manufacturer_string")] public unsafe partial int HidGetManufacturerString(HidDevice* dev, char* @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 395, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_manufacturer_string")] public unsafe partial int HidGetManufacturerString(HidDevice* dev, ref char @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 395, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_manufacturer_string")] public unsafe partial int HidGetManufacturerString(HidDevice* dev, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 399, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_product_string")] public unsafe partial int HidGetProductString(HidDevice* dev, char* @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 399, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_product_string")] public unsafe partial int HidGetProductString(HidDevice* dev, ref char @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 399, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_product_string")] public unsafe partial int HidGetProductString(HidDevice* dev, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 419, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 411, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_serial_number_string")] public unsafe partial int HidGetSerialNumberString(HidDevice* dev, char* @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 419, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 411, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_serial_number_string")] public unsafe partial int HidGetSerialNumberString(HidDevice* dev, ref char @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 419, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 411, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_serial_number_string")] public unsafe partial int HidGetSerialNumberString(HidDevice* dev, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 432, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 424, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_indexed_string")] public unsafe partial int HidGetIndexedString(HidDevice* dev, int string_index, char* @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 432, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 424, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_indexed_string")] public unsafe partial int HidGetIndexedString(HidDevice* dev, int string_index, ref char @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 432, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 424, Column 29 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_get_indexed_string")] public unsafe partial int HidGetIndexedString(HidDevice* dev, int string_index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string @string, nuint maxlen); /// To be documented. - [NativeName("Src", "Line 441, Column 30 in SDL_hidapi.h")] + [NativeName("Src", "Line 433, Column 30 in SDL_hidapi.h")] [NativeApi(EntryPoint = "SDL_hid_ble_scan")] public partial void HidBleScan(SdlBool active); /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHintWithPriority")] public unsafe partial SdlBool SetHintWithPriority([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value, HintPriority priority); /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHintWithPriority")] public unsafe partial SdlBool SetHintWithPriority([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte value, HintPriority priority); /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHintWithPriority")] public unsafe partial SdlBool SetHintWithPriority([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value, HintPriority priority); /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHintWithPriority")] public unsafe partial SdlBool SetHintWithPriority([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value, HintPriority priority); /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHintWithPriority")] public partial SdlBool SetHintWithPriority([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte value, HintPriority priority); /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHintWithPriority")] public partial SdlBool SetHintWithPriority([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value, HintPriority priority); /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHintWithPriority")] public unsafe partial SdlBool SetHintWithPriority([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value, HintPriority priority); /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHintWithPriority")] public partial SdlBool SetHintWithPriority([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte value, HintPriority priority); /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHintWithPriority")] public partial SdlBool SetHintWithPriority([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value, HintPriority priority); /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHint")] public unsafe partial SdlBool SetHint([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value); /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHint")] public unsafe partial SdlBool SetHint([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte value); /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHint")] public unsafe partial SdlBool SetHint([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value); /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHint")] public unsafe partial SdlBool SetHint([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value); /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHint")] public partial SdlBool SetHint([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte value); /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHint")] public partial SdlBool SetHint([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value); /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHint")] public unsafe partial SdlBool SetHint([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value); /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHint")] public partial SdlBool SetHint([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte value); /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_SetHint")] public partial SdlBool SetHint([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value); /// To be documented. - [NativeName("Src", "Line 2781, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3191, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_ResetHint")] public unsafe partial SdlBool ResetHint([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name); /// To be documented. - [NativeName("Src", "Line 2781, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3191, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_ResetHint")] public partial SdlBool ResetHint([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name); /// To be documented. - [NativeName("Src", "Line 2781, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3191, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_ResetHint")] public partial SdlBool ResetHint([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name); /// To be documented. - [NativeName("Src", "Line 2796, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3206, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_ResetHints")] public partial void ResetHints(); /// To be documented. - [NativeName("Src", "Line 2809, Column 38 in SDL_hints.h")] + [NativeName("Src", "Line 3219, Column 38 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_GetHint")] public unsafe partial byte* GetHint([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name); /// To be documented. - [NativeName("Src", "Line 2809, Column 38 in SDL_hints.h")] + [NativeName("Src", "Line 3219, Column 38 in SDL_hints.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetHint")] public unsafe partial string GetHintS([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name); /// To be documented. - [NativeName("Src", "Line 2809, Column 38 in SDL_hints.h")] + [NativeName("Src", "Line 3219, Column 38 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_GetHint")] public unsafe partial byte* GetHint([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name); /// To be documented. - [NativeName("Src", "Line 2809, Column 38 in SDL_hints.h")] + [NativeName("Src", "Line 3219, Column 38 in SDL_hints.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetHint")] public partial string GetHintS([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name); /// To be documented. - [NativeName("Src", "Line 2809, Column 38 in SDL_hints.h")] + [NativeName("Src", "Line 3219, Column 38 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_GetHint")] public unsafe partial byte* GetHint([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name); /// To be documented. - [NativeName("Src", "Line 2809, Column 38 in SDL_hints.h")] + [NativeName("Src", "Line 3219, Column 38 in SDL_hints.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetHint")] public partial string GetHintS([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name); /// To be documented. - [NativeName("Src", "Line 2824, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3234, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_GetHintBoolean")] public unsafe partial SdlBool GetHintBoolean([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, SdlBool default_value); /// To be documented. - [NativeName("Src", "Line 2824, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3234, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_GetHintBoolean")] public partial SdlBool GetHintBoolean([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, SdlBool default_value); /// To be documented. - [NativeName("Src", "Line 2824, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3234, Column 34 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_GetHintBoolean")] public partial SdlBool GetHintBoolean([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, SdlBool default_value); /// To be documented. - [NativeName("Src", "Line 2848, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3258, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_AddHintCallback")] public unsafe partial void AddHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, PfnHintCallback callback, void* userdata); /// To be documented. - [NativeName("Src", "Line 2848, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3258, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_AddHintCallback")] public unsafe partial void AddHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, PfnHintCallback callback, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 2848, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3258, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_AddHintCallback")] public unsafe partial void AddHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, PfnHintCallback callback, void* userdata); /// To be documented. - [NativeName("Src", "Line 2848, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3258, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_AddHintCallback")] public partial void AddHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, PfnHintCallback callback, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 2848, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3258, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_AddHintCallback")] public unsafe partial void AddHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, PfnHintCallback callback, void* userdata); /// To be documented. - [NativeName("Src", "Line 2848, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3258, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_AddHintCallback")] public partial void AddHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, PfnHintCallback callback, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 2864, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3274, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_DelHintCallback")] public unsafe partial void DelHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, PfnHintCallback callback, void* userdata); /// To be documented. - [NativeName("Src", "Line 2864, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3274, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_DelHintCallback")] public unsafe partial void DelHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, PfnHintCallback callback, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 2864, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3274, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_DelHintCallback")] public unsafe partial void DelHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, PfnHintCallback callback, void* userdata); /// To be documented. - [NativeName("Src", "Line 2864, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3274, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_DelHintCallback")] public partial void DelHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name, PfnHintCallback callback, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 2864, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3274, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_DelHintCallback")] public unsafe partial void DelHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, PfnHintCallback callback, void* userdata); /// To be documented. - [NativeName("Src", "Line 2864, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3274, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_DelHintCallback")] public partial void DelHintCallback([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, PfnHintCallback callback, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 2882, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3292, Column 30 in SDL_hints.h")] [NativeApi(EntryPoint = "SDL_ClearHints")] public partial void ClearHints(); /// To be documented. - [NativeName("Src", "Line 65, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 67, Column 31 in SDL_loadso.h")] [NativeApi(EntryPoint = "SDL_LoadObject")] public unsafe partial void* LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* sofile); /// To be documented. - [NativeName("Src", "Line 65, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 67, Column 31 in SDL_loadso.h")] [NativeApi(EntryPoint = "SDL_LoadObject")] public unsafe partial void* LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte sofile); /// To be documented. - [NativeName("Src", "Line 65, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 67, Column 31 in SDL_loadso.h")] [NativeApi(EntryPoint = "SDL_LoadObject")] public unsafe partial void* LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string sofile); /// To be documented. - [NativeName("Src", "Line 92, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 94, Column 31 in SDL_loadso.h")] [NativeApi(EntryPoint = "SDL_LoadFunction")] public unsafe partial void* LoadFunction(void* handle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name); /// To be documented. - [NativeName("Src", "Line 92, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 94, Column 31 in SDL_loadso.h")] [NativeApi(EntryPoint = "SDL_LoadFunction")] public unsafe partial void* LoadFunction(void* handle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name); /// To be documented. - [NativeName("Src", "Line 92, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 94, Column 31 in SDL_loadso.h")] [NativeApi(EntryPoint = "SDL_LoadFunction")] public unsafe partial void* LoadFunction(void* handle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name); /// To be documented. - [NativeName("Src", "Line 92, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 94, Column 31 in SDL_loadso.h")] [NativeApi(EntryPoint = "SDL_LoadFunction")] public unsafe partial void* LoadFunction(ref T0 handle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 92, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 94, Column 31 in SDL_loadso.h")] [NativeApi(EntryPoint = "SDL_LoadFunction")] public unsafe partial void* LoadFunction(ref T0 handle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte name) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 92, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 94, Column 31 in SDL_loadso.h")] [NativeApi(EntryPoint = "SDL_LoadFunction")] public unsafe partial void* LoadFunction(ref T0 handle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 105, Column 30 in SDL_loadso.h")] + [NativeName("Src", "Line 107, Column 30 in SDL_loadso.h")] [NativeApi(EntryPoint = "SDL_UnloadObject")] public unsafe partial void UnloadObject(void* handle); /// To be documented. - [NativeName("Src", "Line 105, Column 30 in SDL_loadso.h")] + [NativeName("Src", "Line 107, Column 30 in SDL_loadso.h")] [NativeApi(EntryPoint = "SDL_UnloadObject")] public partial void UnloadObject(ref T0 handle) where T0 : unmanaged; @@ -12555,142 +12558,142 @@ public unsafe partial class Sdl : NativeAPI public partial void LogMessageV(int category, LogPriority priority, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap); /// To be documented. - [NativeName("Src", "Line 381, Column 30 in SDL_log.h")] + [NativeName("Src", "Line 382, Column 30 in SDL_log.h")] [NativeApi(EntryPoint = "SDL_LogGetOutputFunction")] public unsafe partial void LogGetOutputFunction(PfnLogOutputFunction* callback, void** userdata); /// To be documented. - [NativeName("Src", "Line 381, Column 30 in SDL_log.h")] + [NativeName("Src", "Line 382, Column 30 in SDL_log.h")] [NativeApi(EntryPoint = "SDL_LogGetOutputFunction")] public unsafe partial void LogGetOutputFunction(PfnLogOutputFunction* callback, ref void* userdata); /// To be documented. - [NativeName("Src", "Line 381, Column 30 in SDL_log.h")] + [NativeName("Src", "Line 382, Column 30 in SDL_log.h")] [NativeApi(EntryPoint = "SDL_LogGetOutputFunction")] public unsafe partial void LogGetOutputFunction(ref PfnLogOutputFunction callback, void** userdata); /// To be documented. - [NativeName("Src", "Line 381, Column 30 in SDL_log.h")] + [NativeName("Src", "Line 382, Column 30 in SDL_log.h")] [NativeApi(EntryPoint = "SDL_LogGetOutputFunction")] public unsafe partial void LogGetOutputFunction(ref PfnLogOutputFunction callback, ref void* userdata); /// To be documented. - [NativeName("Src", "Line 393, Column 30 in SDL_log.h")] + [NativeName("Src", "Line 394, Column 30 in SDL_log.h")] [NativeApi(EntryPoint = "SDL_LogSetOutputFunction")] public unsafe partial void LogSetOutputFunction(PfnLogOutputFunction callback, void* userdata); /// To be documented. - [NativeName("Src", "Line 393, Column 30 in SDL_log.h")] + [NativeName("Src", "Line 394, Column 30 in SDL_log.h")] [NativeApi(EntryPoint = "SDL_LogSetOutputFunction")] public partial void LogSetOutputFunction(PfnLogOutputFunction callback, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 140, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 143, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowMessageBox")] public unsafe partial int ShowMessageBox([Flow(Silk.NET.Core.Native.FlowDirection.In)] MessageBoxData* messageboxdata, int* buttonid); /// To be documented. - [NativeName("Src", "Line 140, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 143, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowMessageBox")] public unsafe partial int ShowMessageBox([Flow(Silk.NET.Core.Native.FlowDirection.In)] MessageBoxData* messageboxdata, ref int buttonid); /// To be documented. - [NativeName("Src", "Line 140, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 143, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowMessageBox")] public unsafe partial int ShowMessageBox([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MessageBoxData messageboxdata, int* buttonid); /// To be documented. - [NativeName("Src", "Line 140, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 143, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowMessageBox")] public partial int ShowMessageBox([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly MessageBoxData messageboxdata, ref int buttonid); /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowSimpleMessageBox")] public unsafe partial int ShowSimpleMessageBox(uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* title, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* message, Window* window); /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowSimpleMessageBox")] public unsafe partial int ShowSimpleMessageBox(uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* title, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte message, Window* window); /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowSimpleMessageBox")] public unsafe partial int ShowSimpleMessageBox(uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* title, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string message, Window* window); /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowSimpleMessageBox")] public unsafe partial int ShowSimpleMessageBox(uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte title, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* message, Window* window); /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowSimpleMessageBox")] public unsafe partial int ShowSimpleMessageBox(uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte title, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte message, Window* window); /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowSimpleMessageBox")] public unsafe partial int ShowSimpleMessageBox(uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte title, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string message, Window* window); /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowSimpleMessageBox")] public unsafe partial int ShowSimpleMessageBox(uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string title, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* message, Window* window); /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowSimpleMessageBox")] public unsafe partial int ShowSimpleMessageBox(uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string title, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte message, Window* window); /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] [NativeApi(EntryPoint = "SDL_ShowSimpleMessageBox")] public unsafe partial int ShowSimpleMessageBox(uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string title, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string message, Window* window); /// To be documented. - [NativeName("Src", "Line 66, Column 39 in SDL_metal.h")] + [NativeName("Src", "Line 67, Column 39 in SDL_metal.h")] [NativeApi(EntryPoint = "SDL_Metal_CreateView")] public unsafe partial void* MetalCreateView(Window* window); /// To be documented. - [NativeName("Src", "Line 78, Column 30 in SDL_metal.h")] + [NativeName("Src", "Line 79, Column 30 in SDL_metal.h")] [NativeApi(EntryPoint = "SDL_Metal_DestroyView")] public unsafe partial void MetalDestroyView(void* view); /// To be documented. - [NativeName("Src", "Line 78, Column 30 in SDL_metal.h")] + [NativeName("Src", "Line 79, Column 30 in SDL_metal.h")] [NativeApi(EntryPoint = "SDL_Metal_DestroyView")] public partial void MetalDestroyView(ref T0 view) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 87, Column 31 in SDL_metal.h")] + [NativeName("Src", "Line 88, Column 31 in SDL_metal.h")] [NativeApi(EntryPoint = "SDL_Metal_GetLayer")] public unsafe partial void* MetalGetLayer(void* view); /// To be documented. - [NativeName("Src", "Line 87, Column 31 in SDL_metal.h")] + [NativeName("Src", "Line 88, Column 31 in SDL_metal.h")] [NativeApi(EntryPoint = "SDL_Metal_GetLayer")] public unsafe partial void* MetalGetLayer(ref T0 view) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 102, Column 30 in SDL_metal.h")] + [NativeName("Src", "Line 103, Column 30 in SDL_metal.h")] [NativeApi(EntryPoint = "SDL_Metal_GetDrawableSize")] public unsafe partial void MetalGetDrawableSize(Window* window, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 102, Column 30 in SDL_metal.h")] + [NativeName("Src", "Line 103, Column 30 in SDL_metal.h")] [NativeApi(EntryPoint = "SDL_Metal_GetDrawableSize")] public unsafe partial void MetalGetDrawableSize(Window* window, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 102, Column 30 in SDL_metal.h")] + [NativeName("Src", "Line 103, Column 30 in SDL_metal.h")] [NativeApi(EntryPoint = "SDL_Metal_GetDrawableSize")] public unsafe partial void MetalGetDrawableSize(Window* window, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 102, Column 30 in SDL_metal.h")] + [NativeName("Src", "Line 103, Column 30 in SDL_metal.h")] [NativeApi(EntryPoint = "SDL_Metal_GetDrawableSize")] public unsafe partial void MetalGetDrawableSize(Window* window, ref int w, ref int h); @@ -12715,1867 +12718,1867 @@ public unsafe partial class Sdl : NativeAPI public partial PowerState GetPowerInfo(ref int seconds, ref int percent); /// To be documented. - [NativeName("Src", "Line 169, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 170, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetNumRenderDrivers")] public partial int GetNumRenderDrivers(); /// To be documented. - [NativeName("Src", "Line 185, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 186, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDriverInfo")] public unsafe partial int GetRenderDriverInfo(int index, RendererInfo* info); /// To be documented. - [NativeName("Src", "Line 185, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 186, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDriverInfo")] public partial int GetRenderDriverInfo(int index, ref RendererInfo info); /// To be documented. - [NativeName("Src", "Line 205, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 206, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_CreateWindowAndRenderer")] public unsafe partial int CreateWindowAndRenderer(int width, int height, uint window_flags, Window** window, Renderer** renderer); /// To be documented. - [NativeName("Src", "Line 205, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 206, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_CreateWindowAndRenderer")] public unsafe partial int CreateWindowAndRenderer(int width, int height, uint window_flags, Window** window, ref Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 205, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 206, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_CreateWindowAndRenderer")] public unsafe partial int CreateWindowAndRenderer(int width, int height, uint window_flags, ref Window* window, Renderer** renderer); /// To be documented. - [NativeName("Src", "Line 205, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 206, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_CreateWindowAndRenderer")] public unsafe partial int CreateWindowAndRenderer(int width, int height, uint window_flags, ref Window* window, ref Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 227, Column 40 in SDL_render.h")] + [NativeName("Src", "Line 228, Column 40 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_CreateRenderer")] public unsafe partial Renderer* CreateRenderer(Window* window, int index, uint flags); /// To be documented. - [NativeName("Src", "Line 249, Column 40 in SDL_render.h")] + [NativeName("Src", "Line 250, Column 40 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_CreateSoftwareRenderer")] public unsafe partial Renderer* CreateSoftwareRenderer(Surface* surface); /// To be documented. - [NativeName("Src", "Line 249, Column 40 in SDL_render.h")] + [NativeName("Src", "Line 250, Column 40 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_CreateSoftwareRenderer")] public unsafe partial Renderer* CreateSoftwareRenderer(ref Surface surface); /// To be documented. - [NativeName("Src", "Line 262, Column 40 in SDL_render.h")] + [NativeName("Src", "Line 263, Column 40 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderer")] public unsafe partial Renderer* GetRenderer(Window* window); /// To be documented. - [NativeName("Src", "Line 273, Column 38 in SDL_render.h")] + [NativeName("Src", "Line 274, Column 38 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetWindow")] public unsafe partial Window* RenderGetWindow(Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 288, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 289, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRendererInfo")] public unsafe partial int GetRendererInfo(Renderer* renderer, RendererInfo* info); /// To be documented. - [NativeName("Src", "Line 288, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 289, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRendererInfo")] public unsafe partial int GetRendererInfo(Renderer* renderer, ref RendererInfo info); /// To be documented. - [NativeName("Src", "Line 308, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 309, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRendererOutputSize")] public unsafe partial int GetRendererOutputSize(Renderer* renderer, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 308, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 309, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRendererOutputSize")] public unsafe partial int GetRendererOutputSize(Renderer* renderer, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 308, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 309, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRendererOutputSize")] public unsafe partial int GetRendererOutputSize(Renderer* renderer, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 308, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 309, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRendererOutputSize")] public unsafe partial int GetRendererOutputSize(Renderer* renderer, ref int w, ref int h); /// To be documented. - [NativeName("Src", "Line 333, Column 39 in SDL_render.h")] + [NativeName("Src", "Line 334, Column 39 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_CreateTexture")] public unsafe partial Texture* CreateTexture(Renderer* renderer, uint format, int access, int w, int h); /// To be documented. - [NativeName("Src", "Line 362, Column 39 in SDL_render.h")] + [NativeName("Src", "Line 363, Column 39 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_CreateTextureFromSurface")] public unsafe partial Texture* CreateTextureFromSurface(Renderer* renderer, Surface* surface); /// To be documented. - [NativeName("Src", "Line 362, Column 39 in SDL_render.h")] + [NativeName("Src", "Line 363, Column 39 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_CreateTextureFromSurface")] public unsafe partial Texture* CreateTextureFromSurface(Renderer* renderer, ref Surface surface); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, uint* format, int* access, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, uint* format, int* access, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, uint* format, int* access, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, uint* format, int* access, ref int w, ref int h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, uint* format, ref int access, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, uint* format, ref int access, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, uint* format, ref int access, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, uint* format, ref int access, ref int w, ref int h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, ref uint format, int* access, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, ref uint format, int* access, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, ref uint format, int* access, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, ref uint format, int* access, ref int w, ref int h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, ref uint format, ref int access, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, ref uint format, ref int access, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, ref uint format, ref int access, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_QueryTexture")] public unsafe partial int QueryTexture(Texture* texture, ref uint format, ref int access, ref int w, ref int h); /// To be documented. - [NativeName("Src", "Line 414, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 415, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_SetTextureColorMod")] public unsafe partial int SetTextureColorMod(Texture* texture, byte r, byte g, byte b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, byte* r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, byte* r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, byte* r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, byte* r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, ref byte r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, ref byte r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, ref byte r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, ref byte r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b); /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureColorMod")] public unsafe partial int GetTextureColorMod(Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b); /// To be documented. - [NativeName("Src", "Line 458, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 459, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_SetTextureAlphaMod")] public unsafe partial int SetTextureAlphaMod(Texture* texture, byte alpha); /// To be documented. - [NativeName("Src", "Line 474, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 475, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureAlphaMod")] public unsafe partial int GetTextureAlphaMod(Texture* texture, byte* alpha); /// To be documented. - [NativeName("Src", "Line 474, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 475, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureAlphaMod")] public unsafe partial int GetTextureAlphaMod(Texture* texture, ref byte alpha); /// To be documented. - [NativeName("Src", "Line 474, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 475, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureAlphaMod")] public unsafe partial int GetTextureAlphaMod(Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string alpha); /// To be documented. - [NativeName("Src", "Line 493, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 494, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_SetTextureBlendMode")] public unsafe partial int SetTextureBlendMode(Texture* texture, BlendMode blendMode); /// To be documented. - [NativeName("Src", "Line 508, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 509, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureBlendMode")] public unsafe partial int GetTextureBlendMode(Texture* texture, BlendMode* blendMode); /// To be documented. - [NativeName("Src", "Line 508, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 509, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureBlendMode")] public unsafe partial int GetTextureBlendMode(Texture* texture, ref BlendMode blendMode); /// To be documented. - [NativeName("Src", "Line 524, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 525, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_SetTextureScaleMode")] public unsafe partial int SetTextureScaleMode(Texture* texture, ScaleMode scaleMode); /// To be documented. - [NativeName("Src", "Line 538, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 539, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureScaleMode")] public unsafe partial int GetTextureScaleMode(Texture* texture, ScaleMode* scaleMode); /// To be documented. - [NativeName("Src", "Line 538, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 539, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureScaleMode")] public unsafe partial int GetTextureScaleMode(Texture* texture, ref ScaleMode scaleMode); /// To be documented. - [NativeName("Src", "Line 552, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 553, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_SetTextureUserData")] public unsafe partial int SetTextureUserData(Texture* texture, void* userdata); /// To be documented. - [NativeName("Src", "Line 552, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 553, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_SetTextureUserData")] public unsafe partial int SetTextureUserData(Texture* texture, ref T0 userdata) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 566, Column 32 in SDL_render.h")] + [NativeName("Src", "Line 567, Column 32 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetTextureUserData")] public unsafe partial void* GetTextureUserData(Texture* texture); /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateTexture")] public unsafe partial int UpdateTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pixels, int pitch); /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateTexture")] public unsafe partial int UpdateTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 pixels, int pitch) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateTexture")] public unsafe partial int UpdateTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pixels, int pitch); /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateTexture")] public unsafe partial int UpdateTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 pixels, int pitch) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateYUVTexture")] public unsafe partial int UpdateYUVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UpdateNVTexture")] public unsafe partial int UpdateNVTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string UVplane, int UVpitch); /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTexture")] public unsafe partial int LockTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, void** pixels, int* pitch); /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTexture")] public unsafe partial int LockTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, void** pixels, ref int pitch); /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTexture")] public unsafe partial int LockTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, ref void* pixels, int* pitch); /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTexture")] public unsafe partial int LockTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, ref void* pixels, ref int pitch); /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTexture")] public unsafe partial int LockTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, void** pixels, int* pitch); /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTexture")] public unsafe partial int LockTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, void** pixels, ref int pitch); /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTexture")] public unsafe partial int LockTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, ref void* pixels, int* pitch); /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTexture")] public unsafe partial int LockTexture(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, ref void* pixels, ref int pitch); /// To be documented. - [NativeName("Src", "Line 722, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 723, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTextureToSurface")] public unsafe partial int LockTextureToSurface(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, Surface** surface); /// To be documented. - [NativeName("Src", "Line 722, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 723, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTextureToSurface")] public unsafe partial int LockTextureToSurface(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, ref Surface* surface); /// To be documented. - [NativeName("Src", "Line 722, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 723, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTextureToSurface")] public unsafe partial int LockTextureToSurface(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, Surface** surface); /// To be documented. - [NativeName("Src", "Line 722, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 723, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_LockTextureToSurface")] public unsafe partial int LockTextureToSurface(Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, ref Surface* surface); /// To be documented. - [NativeName("Src", "Line 743, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 744, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_UnlockTexture")] public unsafe partial void UnlockTexture(Texture* texture); /// To be documented. - [NativeName("Src", "Line 755, Column 34 in SDL_render.h")] + [NativeName("Src", "Line 756, Column 34 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderTargetSupported")] public unsafe partial SdlBool RenderTargetSupported(Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 779, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 783, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_SetRenderTarget")] public unsafe partial int SetRenderTarget(Renderer* renderer, Texture* texture); /// To be documented. - [NativeName("Src", "Line 795, Column 39 in SDL_render.h")] + [NativeName("Src", "Line 799, Column 39 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderTarget")] public unsafe partial Texture* GetRenderTarget(Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 823, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 827, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderSetLogicalSize")] public unsafe partial int RenderSetLogicalSize(Renderer* renderer, int w, int h); /// To be documented. - [NativeName("Src", "Line 844, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 848, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetLogicalSize")] public unsafe partial void RenderGetLogicalSize(Renderer* renderer, int* w, int* h); /// To be documented. - [NativeName("Src", "Line 844, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 848, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetLogicalSize")] public unsafe partial void RenderGetLogicalSize(Renderer* renderer, int* w, ref int h); /// To be documented. - [NativeName("Src", "Line 844, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 848, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetLogicalSize")] public unsafe partial void RenderGetLogicalSize(Renderer* renderer, ref int w, int* h); /// To be documented. - [NativeName("Src", "Line 844, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 848, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetLogicalSize")] public unsafe partial void RenderGetLogicalSize(Renderer* renderer, ref int w, ref int h); /// To be documented. - [NativeName("Src", "Line 863, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 867, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderSetIntegerScale")] public unsafe partial int RenderSetIntegerScale(Renderer* renderer, SdlBool enable); /// To be documented. - [NativeName("Src", "Line 877, Column 34 in SDL_render.h")] + [NativeName("Src", "Line 881, Column 34 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetIntegerScale")] public unsafe partial SdlBool RenderGetIntegerScale(Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 895, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 899, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderSetViewport")] public unsafe partial int RenderSetViewport(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 895, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 899, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderSetViewport")] public unsafe partial int RenderSetViewport(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 908, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 912, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetViewport")] public unsafe partial void RenderGetViewport(Renderer* renderer, Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 908, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 912, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetViewport")] public unsafe partial void RenderGetViewport(Renderer* renderer, ref Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 926, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 930, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderSetClipRect")] public unsafe partial int RenderSetClipRect(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 926, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 930, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderSetClipRect")] public unsafe partial int RenderSetClipRect(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 942, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 946, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetClipRect")] public unsafe partial void RenderGetClipRect(Renderer* renderer, Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 942, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 946, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetClipRect")] public unsafe partial void RenderGetClipRect(Renderer* renderer, ref Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 957, Column 34 in SDL_render.h")] + [NativeName("Src", "Line 961, Column 34 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderIsClipEnabled")] public unsafe partial SdlBool RenderIsClipEnabled(Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 982, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 986, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderSetScale")] public unsafe partial int RenderSetScale(Renderer* renderer, float scaleX, float scaleY); /// To be documented. - [NativeName("Src", "Line 996, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1000, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetScale")] public unsafe partial void RenderGetScale(Renderer* renderer, float* scaleX, float* scaleY); /// To be documented. - [NativeName("Src", "Line 996, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1000, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetScale")] public unsafe partial void RenderGetScale(Renderer* renderer, float* scaleX, ref float scaleY); /// To be documented. - [NativeName("Src", "Line 996, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1000, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetScale")] public unsafe partial void RenderGetScale(Renderer* renderer, ref float scaleX, float* scaleY); /// To be documented. - [NativeName("Src", "Line 996, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1000, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetScale")] public unsafe partial void RenderGetScale(Renderer* renderer, ref float scaleX, ref float scaleY); /// To be documented. - [NativeName("Src", "Line 1020, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1024, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderWindowToLogical")] public unsafe partial void RenderWindowToLogical(Renderer* renderer, int windowX, int windowY, float* logicalX, float* logicalY); /// To be documented. - [NativeName("Src", "Line 1020, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1024, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderWindowToLogical")] public unsafe partial void RenderWindowToLogical(Renderer* renderer, int windowX, int windowY, float* logicalX, ref float logicalY); /// To be documented. - [NativeName("Src", "Line 1020, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1024, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderWindowToLogical")] public unsafe partial void RenderWindowToLogical(Renderer* renderer, int windowX, int windowY, ref float logicalX, float* logicalY); /// To be documented. - [NativeName("Src", "Line 1020, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1024, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderWindowToLogical")] public unsafe partial void RenderWindowToLogical(Renderer* renderer, int windowX, int windowY, ref float logicalX, ref float logicalY); /// To be documented. - [NativeName("Src", "Line 1046, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1050, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderLogicalToWindow")] public unsafe partial void RenderLogicalToWindow(Renderer* renderer, float logicalX, float logicalY, int* windowX, int* windowY); /// To be documented. - [NativeName("Src", "Line 1046, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1050, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderLogicalToWindow")] public unsafe partial void RenderLogicalToWindow(Renderer* renderer, float logicalX, float logicalY, int* windowX, ref int windowY); /// To be documented. - [NativeName("Src", "Line 1046, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1050, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderLogicalToWindow")] public unsafe partial void RenderLogicalToWindow(Renderer* renderer, float logicalX, float logicalY, ref int windowX, int* windowY); /// To be documented. - [NativeName("Src", "Line 1046, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1050, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderLogicalToWindow")] public unsafe partial void RenderLogicalToWindow(Renderer* renderer, float logicalX, float logicalY, ref int windowX, ref int windowY); /// To be documented. - [NativeName("Src", "Line 1079, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1083, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_SetRenderDrawColor")] public unsafe partial int SetRenderDrawColor(Renderer* renderer, byte r, byte g, byte b, byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, byte* g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, byte* g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, byte* g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, byte* g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, byte* g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, ref byte g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, ref byte g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, ref byte g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, ref byte g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, ref byte g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, ref byte g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, byte* g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, byte* g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, byte* g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, byte* g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, byte* g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, ref byte g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, ref byte g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, ref byte g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, ref byte g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, ref byte g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, ref byte g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, ref byte r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, ref byte g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, ref byte b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, ref byte a); /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawColor")] public unsafe partial int GetRenderDrawColor(Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a); /// To be documented. - [NativeName("Src", "Line 1128, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1132, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_SetRenderDrawBlendMode")] public unsafe partial int SetRenderDrawBlendMode(Renderer* renderer, BlendMode blendMode); /// To be documented. - [NativeName("Src", "Line 1143, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1147, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawBlendMode")] public unsafe partial int GetRenderDrawBlendMode(Renderer* renderer, BlendMode* blendMode); /// To be documented. - [NativeName("Src", "Line 1143, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1147, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GetRenderDrawBlendMode")] public unsafe partial int GetRenderDrawBlendMode(Renderer* renderer, ref BlendMode blendMode); /// To be documented. - [NativeName("Src", "Line 1160, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1164, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderClear")] public unsafe partial int RenderClear(Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 1187, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1191, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawPoint")] public unsafe partial int RenderDrawPoint(Renderer* renderer, int x, int y); /// To be documented. - [NativeName("Src", "Line 1213, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1217, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawPoints")] public unsafe partial int RenderDrawPoints(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Point* points, int count); /// To be documented. - [NativeName("Src", "Line 1213, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1217, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawPoints")] public unsafe partial int RenderDrawPoints(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Point points, int count); /// To be documented. - [NativeName("Src", "Line 1244, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1248, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawLine")] public unsafe partial int RenderDrawLine(Renderer* renderer, int x1, int y1, int x2, int y2); /// To be documented. - [NativeName("Src", "Line 1270, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1274, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawLines")] public unsafe partial int RenderDrawLines(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Point* points, int count); /// To be documented. - [NativeName("Src", "Line 1270, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1274, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawLines")] public unsafe partial int RenderDrawLines(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Point points, int count); /// To be documented. - [NativeName("Src", "Line 1296, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1300, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawRect")] public unsafe partial int RenderDrawRect(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 1296, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1300, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawRect")] public unsafe partial int RenderDrawRect(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 1322, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1326, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawRects")] public unsafe partial int RenderDrawRects(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rects, int count); /// To be documented. - [NativeName("Src", "Line 1322, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1326, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawRects")] public unsafe partial int RenderDrawRects(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rects, int count); /// To be documented. - [NativeName("Src", "Line 1352, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1356, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderFillRect")] public unsafe partial int RenderFillRect(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect); /// To be documented. - [NativeName("Src", "Line 1352, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1356, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderFillRect")] public unsafe partial int RenderFillRect(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect); /// To be documented. - [NativeName("Src", "Line 1377, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1381, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderFillRects")] public unsafe partial int RenderFillRects(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rects, int count); /// To be documented. - [NativeName("Src", "Line 1377, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1381, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderFillRects")] public unsafe partial int RenderFillRects(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rects, int count); /// To be documented. - [NativeName("Src", "Line 1409, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1414, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopy")] public unsafe partial int RenderCopy(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 1409, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1414, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopy")] public unsafe partial int RenderCopy(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 1409, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1414, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopy")] public unsafe partial int RenderCopy(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect); /// To be documented. - [NativeName("Src", "Line 1409, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1414, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopy")] public unsafe partial int RenderCopy(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect); /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyEx")] public unsafe partial int RenderCopyEx(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Point* center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyEx")] public unsafe partial int RenderCopyEx(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Point center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyEx")] public unsafe partial int RenderCopyEx(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Point* center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyEx")] public unsafe partial int RenderCopyEx(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Point center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyEx")] public unsafe partial int RenderCopyEx(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Point* center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyEx")] public unsafe partial int RenderCopyEx(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Point center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyEx")] public unsafe partial int RenderCopyEx(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Point* center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyEx")] public unsafe partial int RenderCopyEx(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Point center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1472, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1478, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawPointF")] public unsafe partial int RenderDrawPointF(Renderer* renderer, float x, float y); /// To be documented. - [NativeName("Src", "Line 1485, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1491, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawPointsF")] public unsafe partial int RenderDrawPointsF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FPoint* points, int count); /// To be documented. - [NativeName("Src", "Line 1485, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1491, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawPointsF")] public unsafe partial int RenderDrawPointsF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FPoint points, int count); /// To be documented. - [NativeName("Src", "Line 1501, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1507, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawLineF")] public unsafe partial int RenderDrawLineF(Renderer* renderer, float x1, float y1, float x2, float y2); /// To be documented. - [NativeName("Src", "Line 1515, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1521, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawLinesF")] public unsafe partial int RenderDrawLinesF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FPoint* points, int count); /// To be documented. - [NativeName("Src", "Line 1515, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1521, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawLinesF")] public unsafe partial int RenderDrawLinesF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FPoint points, int count); /// To be documented. - [NativeName("Src", "Line 1529, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1535, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawRectF")] public unsafe partial int RenderDrawRectF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* rect); /// To be documented. - [NativeName("Src", "Line 1529, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1535, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawRectF")] public unsafe partial int RenderDrawRectF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FRect rect); /// To be documented. - [NativeName("Src", "Line 1543, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1549, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawRectsF")] public unsafe partial int RenderDrawRectsF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* rects, int count); /// To be documented. - [NativeName("Src", "Line 1543, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1549, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderDrawRectsF")] public unsafe partial int RenderDrawRectsF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FRect rects, int count); /// To be documented. - [NativeName("Src", "Line 1558, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1564, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderFillRectF")] public unsafe partial int RenderFillRectF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* rect); /// To be documented. - [NativeName("Src", "Line 1558, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1564, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderFillRectF")] public unsafe partial int RenderFillRectF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FRect rect); /// To be documented. - [NativeName("Src", "Line 1572, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1578, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderFillRectsF")] public unsafe partial int RenderFillRectsF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* rects, int count); /// To be documented. - [NativeName("Src", "Line 1572, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1578, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderFillRectsF")] public unsafe partial int RenderFillRectsF(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FRect rects, int count); /// To be documented. - [NativeName("Src", "Line 1590, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1596, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyF")] public unsafe partial int RenderCopyF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* dstrect); /// To be documented. - [NativeName("Src", "Line 1590, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1596, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyF")] public unsafe partial int RenderCopyF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FRect dstrect); /// To be documented. - [NativeName("Src", "Line 1590, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1596, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyF")] public unsafe partial int RenderCopyF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* dstrect); /// To be documented. - [NativeName("Src", "Line 1590, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1596, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyF")] public unsafe partial int RenderCopyF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FRect dstrect); /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyExF")] public unsafe partial int RenderCopyExF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FPoint* center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyExF")] public unsafe partial int RenderCopyExF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FPoint center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyExF")] public unsafe partial int RenderCopyExF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FRect dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FPoint* center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyExF")] public unsafe partial int RenderCopyExF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FRect dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FPoint center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyExF")] public unsafe partial int RenderCopyExF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FPoint* center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyExF")] public unsafe partial int RenderCopyExF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FPoint center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyExF")] public unsafe partial int RenderCopyExF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FRect dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FPoint* center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderCopyExF")] public unsafe partial int RenderCopyExF(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FRect dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly FPoint center, RendererFlip flip); /// To be documented. - [NativeName("Src", "Line 1644, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1650, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometry")] public unsafe partial int RenderGeometry(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Vertex* vertices, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int* indices, int num_indices); /// To be documented. - [NativeName("Src", "Line 1644, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1650, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometry")] public unsafe partial int RenderGeometry(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Vertex* vertices, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly int indices, int num_indices); /// To be documented. - [NativeName("Src", "Line 1644, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1650, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometry")] public unsafe partial int RenderGeometry(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Vertex vertices, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int* indices, int num_indices); /// To be documented. - [NativeName("Src", "Line 1644, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1650, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometry")] public unsafe partial int RenderGeometry(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Vertex vertices, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly int indices, int num_indices); /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices); /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 indices, int num_indices, int size_indices) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices); /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 indices, int num_indices, int size_indices) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Color color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices); /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Color color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 indices, int num_indices, int size_indices) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Color color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices); /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Color color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 indices, int num_indices, int size_indices) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices); /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 indices, int num_indices, int size_indices) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices); /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 indices, int num_indices, int size_indices) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Color color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices); /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Color color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 indices, int num_indices, int size_indices) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Color color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices); /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGeometryRaw")] public unsafe partial int RenderGeometryRaw(Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Color color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly float uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly T0 indices, int num_indices, int size_indices) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1708, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1714, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderReadPixels")] public unsafe partial int RenderReadPixels(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, uint format, void* pixels, int pitch); /// To be documented. - [NativeName("Src", "Line 1708, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1714, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderReadPixels")] public unsafe partial int RenderReadPixels(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, uint format, ref T0 pixels, int pitch) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1708, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1714, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderReadPixels")] public unsafe partial int RenderReadPixels(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, uint format, void* pixels, int pitch); /// To be documented. - [NativeName("Src", "Line 1708, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1714, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderReadPixels")] public unsafe partial int RenderReadPixels(Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly Silk.NET.Maths.Rectangle rect, uint format, ref T0 pixels, int pitch) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 1753, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1760, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderPresent")] public unsafe partial void RenderPresent(Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 1768, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1775, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_DestroyTexture")] public unsafe partial void DestroyTexture(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1782, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1789, Column 30 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_DestroyRenderer")] public unsafe partial void DestroyRenderer(Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 1813, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1820, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderFlush")] public unsafe partial int RenderFlush(Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 1851, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1858, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GL_BindTexture")] public unsafe partial int GLBindTexture(Texture* texture, float* texw, float* texh); /// To be documented. - [NativeName("Src", "Line 1851, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1858, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GL_BindTexture")] public unsafe partial int GLBindTexture(Texture* texture, float* texw, ref float texh); /// To be documented. - [NativeName("Src", "Line 1851, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1858, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GL_BindTexture")] public unsafe partial int GLBindTexture(Texture* texture, ref float texw, float* texh); /// To be documented. - [NativeName("Src", "Line 1851, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1858, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GL_BindTexture")] public unsafe partial int GLBindTexture(Texture* texture, ref float texw, ref float texh); /// To be documented. - [NativeName("Src", "Line 1866, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1874, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_GL_UnbindTexture")] public unsafe partial int GLUnbindTexture(Texture* texture); /// To be documented. - [NativeName("Src", "Line 1882, Column 31 in SDL_render.h")] + [NativeName("Src", "Line 1890, Column 31 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetMetalLayer")] public unsafe partial void* RenderGetMetalLayer(Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 1903, Column 31 in SDL_render.h")] + [NativeName("Src", "Line 1911, Column 31 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderGetMetalCommandEncoder")] public unsafe partial void* RenderGetMetalCommandEncoder(Renderer* renderer); /// To be documented. - [NativeName("Src", "Line 1914, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1922, Column 29 in SDL_render.h")] [NativeApi(EntryPoint = "SDL_RenderSetVSync")] public unsafe partial int RenderSetVSync(Renderer* renderer, int vsync); @@ -14700,195 +14703,195 @@ public unsafe partial class Sdl : NativeAPI public unsafe partial int IPhoneSetAnimationCallback(Window* window, int interval, PfnFreeFunc callback, ref T0 callbackParam) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 243, Column 30 in SDL_system.h")] + [NativeName("Src", "Line 244, Column 30 in SDL_system.h")] [NativeApi(EntryPoint = "SDL_iPhoneSetEventPump")] public partial void IPhoneSetEventPump(SdlBool enabled); /// To be documented. - [NativeName("Src", "Line 268, Column 32 in SDL_system.h")] + [NativeName("Src", "Line 272, Column 32 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidGetJNIEnv")] public unsafe partial void* AndroidGetJNIEnv(); /// To be documented. - [NativeName("Src", "Line 290, Column 32 in SDL_system.h")] + [NativeName("Src", "Line 294, Column 32 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidGetActivity")] public unsafe partial void* AndroidGetActivity(); /// To be documented. - [NativeName("Src", "Line 322, Column 29 in SDL_system.h")] + [NativeName("Src", "Line 326, Column 29 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_GetAndroidSDKVersion")] public partial int GetAndroidSDKVersion(); /// To be documented. - [NativeName("Src", "Line 331, Column 34 in SDL_system.h")] + [NativeName("Src", "Line 335, Column 34 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_IsAndroidTV")] public partial SdlBool IsAndroidTV(); /// To be documented. - [NativeName("Src", "Line 340, Column 34 in SDL_system.h")] + [NativeName("Src", "Line 344, Column 34 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_IsChromebook")] public partial SdlBool IsChromebook(); /// To be documented. - [NativeName("Src", "Line 349, Column 34 in SDL_system.h")] + [NativeName("Src", "Line 353, Column 34 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_IsDeXMode")] public partial SdlBool IsDeXMode(); /// To be documented. - [NativeName("Src", "Line 356, Column 30 in SDL_system.h")] + [NativeName("Src", "Line 360, Column 30 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidBackButton")] public partial void AndroidBackButton(); /// To be documented. - [NativeName("Src", "Line 381, Column 38 in SDL_system.h")] + [NativeName("Src", "Line 385, Column 38 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidGetInternalStoragePath")] public unsafe partial byte* AndroidGetInternalStoragePath(); /// To be documented. - [NativeName("Src", "Line 381, Column 38 in SDL_system.h")] + [NativeName("Src", "Line 385, Column 38 in SDL_system.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidGetInternalStoragePath")] public partial string AndroidGetInternalStoragePathS(); /// To be documented. - [NativeName("Src", "Line 398, Column 29 in SDL_system.h")] + [NativeName("Src", "Line 402, Column 29 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidGetExternalStorageState")] public partial int AndroidGetExternalStorageState(); /// To be documented. - [NativeName("Src", "Line 416, Column 38 in SDL_system.h")] + [NativeName("Src", "Line 420, Column 38 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidGetExternalStoragePath")] public unsafe partial byte* AndroidGetExternalStoragePath(); /// To be documented. - [NativeName("Src", "Line 416, Column 38 in SDL_system.h")] + [NativeName("Src", "Line 420, Column 38 in SDL_system.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidGetExternalStoragePath")] public partial string AndroidGetExternalStoragePathS(); /// To be documented. - [NativeName("Src", "Line 428, Column 34 in SDL_system.h")] + [NativeName("Src", "Line 432, Column 34 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidRequestPermission")] public unsafe partial SdlBool AndroidRequestPermission([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* permission); /// To be documented. - [NativeName("Src", "Line 428, Column 34 in SDL_system.h")] + [NativeName("Src", "Line 432, Column 34 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidRequestPermission")] public partial SdlBool AndroidRequestPermission([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte permission); /// To be documented. - [NativeName("Src", "Line 428, Column 34 in SDL_system.h")] + [NativeName("Src", "Line 432, Column 34 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidRequestPermission")] public partial SdlBool AndroidRequestPermission([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string permission); /// To be documented. - [NativeName("Src", "Line 453, Column 29 in SDL_system.h")] + [NativeName("Src", "Line 457, Column 29 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidShowToast")] public unsafe partial int AndroidShowToast([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* message, int duration, int gravity, int xoffset, int yoffset); /// To be documented. - [NativeName("Src", "Line 453, Column 29 in SDL_system.h")] + [NativeName("Src", "Line 457, Column 29 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidShowToast")] public partial int AndroidShowToast([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte message, int duration, int gravity, int xoffset, int yoffset); /// To be documented. - [NativeName("Src", "Line 453, Column 29 in SDL_system.h")] + [NativeName("Src", "Line 457, Column 29 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidShowToast")] public partial int AndroidShowToast([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string message, int duration, int gravity, int xoffset, int yoffset); /// To be documented. - [NativeName("Src", "Line 465, Column 29 in SDL_system.h")] + [NativeName("Src", "Line 469, Column 29 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_AndroidSendMessage")] public partial int AndroidSendMessage(uint command, int param); /// To be documented. - [NativeName("Src", "Line 536, Column 41 in SDL_system.h")] + [NativeName("Src", "Line 540, Column 41 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_WinRTGetFSPathUNICODE")] public unsafe partial char* WinRTGetFSPathUNICODE(WinRTPath pathType); /// To be documented. - [NativeName("Src", "Line 536, Column 41 in SDL_system.h")] + [NativeName("Src", "Line 540, Column 41 in SDL_system.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_WinRTGetFSPathUNICODE")] public partial string WinRTGetFSPathUNICODES(WinRTPath pathType); /// To be documented. - [NativeName("Src", "Line 559, Column 38 in SDL_system.h")] + [NativeName("Src", "Line 563, Column 38 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_WinRTGetFSPathUTF8")] public unsafe partial byte* WinRTGetFSPathUTF8(WinRTPath pathType); /// To be documented. - [NativeName("Src", "Line 559, Column 38 in SDL_system.h")] + [NativeName("Src", "Line 563, Column 38 in SDL_system.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_WinRTGetFSPathUTF8")] public partial string WinRTGetFSPathUTF8S(WinRTPath pathType); /// To be documented. - [NativeName("Src", "Line 568, Column 48 in SDL_system.h")] + [NativeName("Src", "Line 572, Column 48 in SDL_system.h")] [ExcludeFromOverride(0)] [NativeApi(EntryPoint = "SDL_WinRTGetDeviceFamily")] public partial WinRTDeviceFamily WinRTGetDeviceFamily(); /// To be documented. - [NativeName("Src", "Line 581, Column 34 in SDL_system.h")] + [NativeName("Src", "Line 585, Column 34 in SDL_system.h")] [NativeApi(EntryPoint = "SDL_IsTablet")] public partial SdlBool IsTablet(); /// To be documented. - [NativeName("Src", "Line 584, Column 30 in SDL_system.h")] + [NativeName("Src", "Line 588, Column 30 in SDL_system.h")] [NativeApi(EntryPoint = "SDL_OnApplicationWillTerminate")] public partial void OnApplicationWillTerminate(); /// To be documented. - [NativeName("Src", "Line 585, Column 30 in SDL_system.h")] + [NativeName("Src", "Line 589, Column 30 in SDL_system.h")] [NativeApi(EntryPoint = "SDL_OnApplicationDidReceiveMemoryWarning")] public partial void OnApplicationDidReceiveMemoryWarning(); /// To be documented. - [NativeName("Src", "Line 586, Column 30 in SDL_system.h")] + [NativeName("Src", "Line 590, Column 30 in SDL_system.h")] [NativeApi(EntryPoint = "SDL_OnApplicationWillResignActive")] public partial void OnApplicationWillResignActive(); /// To be documented. - [NativeName("Src", "Line 587, Column 30 in SDL_system.h")] + [NativeName("Src", "Line 591, Column 30 in SDL_system.h")] [NativeApi(EntryPoint = "SDL_OnApplicationDidEnterBackground")] public partial void OnApplicationDidEnterBackground(); /// To be documented. - [NativeName("Src", "Line 588, Column 30 in SDL_system.h")] + [NativeName("Src", "Line 592, Column 30 in SDL_system.h")] [NativeApi(EntryPoint = "SDL_OnApplicationWillEnterForeground")] public partial void OnApplicationWillEnterForeground(); /// To be documented. - [NativeName("Src", "Line 589, Column 30 in SDL_system.h")] + [NativeName("Src", "Line 593, Column 30 in SDL_system.h")] [NativeApi(EntryPoint = "SDL_OnApplicationDidBecomeActive")] public partial void OnApplicationDidBecomeActive(); /// To be documented. - [NativeName("Src", "Line 591, Column 30 in SDL_system.h")] + [NativeName("Src", "Line 595, Column 30 in SDL_system.h")] [NativeApi(EntryPoint = "SDL_OnApplicationDidChangeStatusBarOrientation")] public partial void OnApplicationDidChangeStatusBarOrientation(); @@ -14933,28 +14936,28 @@ public unsafe partial class Sdl : NativeAPI public partial SdlBool RemoveTimer(int id); /// To be documented. - [NativeName("Src", "Line 141, Column 30 in SDL_version.h")] + [NativeName("Src", "Line 142, Column 30 in SDL_version.h")] [NativeApi(EntryPoint = "SDL_GetVersion")] public unsafe partial void GetVersion(Version* ver); /// To be documented. - [NativeName("Src", "Line 141, Column 30 in SDL_version.h")] + [NativeName("Src", "Line 142, Column 30 in SDL_version.h")] [NativeApi(EntryPoint = "SDL_GetVersion")] public partial void GetVersion(ref Version ver); /// To be documented. - [NativeName("Src", "Line 170, Column 37 in SDL_version.h")] + [NativeName("Src", "Line 171, Column 37 in SDL_version.h")] [NativeApi(EntryPoint = "SDL_GetRevision")] public unsafe partial byte* GetRevision(); /// To be documented. - [NativeName("Src", "Line 170, Column 37 in SDL_version.h")] + [NativeName("Src", "Line 171, Column 37 in SDL_version.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "SDL_GetRevision")] public partial string GetRevisionS(); /// To be documented. - [NativeName("Src", "Line 193, Column 44 in SDL_version.h")] + [NativeName("Src", "Line 194, Column 44 in SDL_version.h")] [NativeApi(EntryPoint = "SDL_GetRevisionNumber")] public partial int GetRevisionNumber(); @@ -14979,32 +14982,32 @@ public unsafe partial class Sdl : NativeAPI public partial int OpenURL([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string url); /// To be documented. - [NativeName("Src", "Line 144, Column 29 in SDL.h")] + [NativeName("Src", "Line 145, Column 29 in SDL.h")] [NativeApi(EntryPoint = "SDL_Init")] public partial int Init(uint flags); /// To be documented. - [NativeName("Src", "Line 161, Column 29 in SDL.h")] + [NativeName("Src", "Line 162, Column 29 in SDL.h")] [NativeApi(EntryPoint = "SDL_InitSubSystem")] public partial int InitSubSystem(uint flags); /// To be documented. - [NativeName("Src", "Line 183, Column 30 in SDL.h")] + [NativeName("Src", "Line 184, Column 30 in SDL.h")] [NativeApi(EntryPoint = "SDL_QuitSubSystem")] public partial void QuitSubSystem(uint flags); /// To be documented. - [NativeName("Src", "Line 199, Column 32 in SDL.h")] + [NativeName("Src", "Line 200, Column 32 in SDL.h")] [NativeApi(EntryPoint = "SDL_WasInit")] public partial uint WasInit(uint flags); /// To be documented. - [NativeName("Src", "Line 223, Column 30 in SDL.h")] + [NativeName("Src", "Line 224, Column 30 in SDL.h")] [NativeApi(EntryPoint = "SDL_Quit")] public partial void Quit(); /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public unsafe byte* Strtokr(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, string[] saveptrSa) { // StringArrayOverloader @@ -15016,7 +15019,7 @@ public unsafe partial class Sdl : NativeAPI } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] public unsafe string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, string[] saveptrSa) { @@ -15029,7 +15032,7 @@ public unsafe string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public unsafe byte* Strtokr(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, string[] saveptrSa) { // StringArrayOverloader @@ -15041,7 +15044,7 @@ public unsafe string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] public unsafe string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, string[] saveptrSa) { @@ -15054,7 +15057,7 @@ public unsafe string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public unsafe byte* Strtokr(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, string[] saveptrSa) { // StringArrayOverloader @@ -15066,7 +15069,7 @@ public unsafe string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] public unsafe string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, string[] saveptrSa) { @@ -15079,7 +15082,7 @@ public unsafe string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public unsafe byte* Strtokr(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, string[] saveptrSa) { // StringArrayOverloader @@ -15091,7 +15094,7 @@ public unsafe string StrtokrS(byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] public unsafe string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, string[] saveptrSa) { @@ -15104,7 +15107,7 @@ public unsafe string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirect } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public unsafe byte* Strtokr(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, string[] saveptrSa) { // StringArrayOverloader @@ -15116,7 +15119,7 @@ public unsafe string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirect } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] public unsafe string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, string[] saveptrSa) { @@ -15129,7 +15132,7 @@ public unsafe string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirect } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public unsafe byte* Strtokr(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, string[] saveptrSa) { // StringArrayOverloader @@ -15141,7 +15144,7 @@ public unsafe string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirect } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] public unsafe string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, string[] saveptrSa) { @@ -15154,7 +15157,7 @@ public unsafe string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirect } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public unsafe byte* Strtokr([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, string[] saveptrSa) { // StringArrayOverloader @@ -15166,7 +15169,7 @@ public unsafe string StrtokrS(ref byte s1, [Flow(Silk.NET.Core.Native.FlowDirect } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] public unsafe string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, string[] saveptrSa) { @@ -15179,7 +15182,7 @@ public unsafe string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType. } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public unsafe byte* Strtokr([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, string[] saveptrSa) { // StringArrayOverloader @@ -15191,7 +15194,7 @@ public unsafe string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType. } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] public unsafe string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte s2, string[] saveptrSa) { @@ -15204,7 +15207,7 @@ public unsafe string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType. } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public unsafe byte* Strtokr([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, string[] saveptrSa) { // StringArrayOverloader @@ -15216,7 +15219,7 @@ public unsafe string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType. } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] public unsafe string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, string[] saveptrSa) { @@ -15229,7 +15232,7 @@ public unsafe string StrtokrS([UnmanagedType(Silk.NET.Core.Native.UnmanagedType. } /// To be documented. - [NativeName("Src", "Line 603, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 618, Column 30 in SDL_stdinc.h")] public unsafe int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15241,7 +15244,7 @@ public unsafe int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str } /// To be documented. - [NativeName("Src", "Line 603, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 618, Column 30 in SDL_stdinc.h")] public unsafe int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15253,7 +15256,7 @@ public unsafe int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref reado } /// To be documented. - [NativeName("Src", "Line 603, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 618, Column 30 in SDL_stdinc.h")] public unsafe int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15265,7 +15268,7 @@ public unsafe int Strtol([Flow(Silk.NET.Core.Native.FlowDirection.In), Unmanaged } /// To be documented. - [NativeName("Src", "Line 604, Column 39 in SDL_stdinc.h")] + [NativeName("Src", "Line 619, Column 39 in SDL_stdinc.h")] public unsafe uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15277,7 +15280,7 @@ public unsafe uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s } /// To be documented. - [NativeName("Src", "Line 604, Column 39 in SDL_stdinc.h")] + [NativeName("Src", "Line 619, Column 39 in SDL_stdinc.h")] public unsafe uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15289,7 +15292,7 @@ public unsafe uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref rea } /// To be documented. - [NativeName("Src", "Line 604, Column 39 in SDL_stdinc.h")] + [NativeName("Src", "Line 619, Column 39 in SDL_stdinc.h")] public unsafe uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15301,7 +15304,7 @@ public unsafe uint Strtoul([Flow(Silk.NET.Core.Native.FlowDirection.In), Unmanag } /// To be documented. - [NativeName("Src", "Line 605, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 620, Column 32 in SDL_stdinc.h")] public unsafe long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15313,7 +15316,7 @@ public unsafe long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s } /// To be documented. - [NativeName("Src", "Line 605, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 620, Column 32 in SDL_stdinc.h")] public unsafe long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15325,7 +15328,7 @@ public unsafe long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref rea } /// To be documented. - [NativeName("Src", "Line 605, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 620, Column 32 in SDL_stdinc.h")] public unsafe long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15337,7 +15340,7 @@ public unsafe long Strtoll([Flow(Silk.NET.Core.Native.FlowDirection.In), Unmanag } /// To be documented. - [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 621, Column 32 in SDL_stdinc.h")] public unsafe ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15349,7 +15352,7 @@ public unsafe ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* } /// To be documented. - [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 621, Column 32 in SDL_stdinc.h")] public unsafe ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15361,7 +15364,7 @@ public unsafe ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref r } /// To be documented. - [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 621, Column 32 in SDL_stdinc.h")] public unsafe ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, string[] endpSa, int @base) { // StringArrayOverloader @@ -15373,7 +15376,7 @@ public unsafe ulong Strtoull([Flow(Silk.NET.Core.Native.FlowDirection.In), Unman } /// To be documented. - [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 622, Column 32 in SDL_stdinc.h")] public unsafe double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str, string[] endpSa) { // StringArrayOverloader @@ -15385,7 +15388,7 @@ public unsafe double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* } /// To be documented. - [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 622, Column 32 in SDL_stdinc.h")] public unsafe double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte str, string[] endpSa) { // StringArrayOverloader @@ -15397,7 +15400,7 @@ public unsafe double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In)] ref re } /// To be documented. - [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 622, Column 32 in SDL_stdinc.h")] public unsafe double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str, string[] endpSa) { // StringArrayOverloader @@ -15409,7 +15412,7 @@ public unsafe double Strtod([Flow(Silk.NET.Core.Native.FlowDirection.In), Unmana } /// To be documented. - [NativeName("Src", "Line 618, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 633, Column 29 in SDL_stdinc.h")] public unsafe int Asprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt) { // StringArrayOverloader @@ -15421,7 +15424,7 @@ public unsafe int Asprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirec } /// To be documented. - [NativeName("Src", "Line 618, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 633, Column 29 in SDL_stdinc.h")] public unsafe int Asprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt) { // StringArrayOverloader @@ -15433,7 +15436,7 @@ public unsafe int Asprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirec } /// To be documented. - [NativeName("Src", "Line 618, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 633, Column 29 in SDL_stdinc.h")] public unsafe int Asprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt) { // StringArrayOverloader @@ -15445,7 +15448,7 @@ public unsafe int Asprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirec } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, byte* ap) { // StringArrayOverloader @@ -15457,7 +15460,7 @@ public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDire } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, ref byte ap) { // StringArrayOverloader @@ -15469,7 +15472,7 @@ public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDire } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // StringArrayOverloader @@ -15481,7 +15484,7 @@ public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDire } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, byte* ap) { // StringArrayOverloader @@ -15493,7 +15496,7 @@ public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDire } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, ref byte ap) { // StringArrayOverloader @@ -15505,7 +15508,7 @@ public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDire } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // StringArrayOverloader @@ -15517,7 +15520,7 @@ public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDire } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, byte* ap) { // StringArrayOverloader @@ -15529,7 +15532,7 @@ public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDire } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, ref byte ap) { // StringArrayOverloader @@ -15541,7 +15544,7 @@ public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDire } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // StringArrayOverloader @@ -15553,7 +15556,7 @@ public unsafe int Vasprintf(string[] strpSa, [Flow(Silk.NET.Core.Native.FlowDire } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] string[] inbufSa, nuint* inbytesleft, string[] outbufSa, nuint* outbytesleft) { // StringArrayOverloader @@ -15568,7 +15571,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] string[] inbufSa, nuint* inbytesleft, string[] outbufSa, ref nuint outbytesleft) { // StringArrayOverloader @@ -15583,7 +15586,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] string[] inbufSa, nuint* inbytesleft, ref byte* outbuf, nuint* outbytesleft) { // StringArrayOverloader @@ -15595,7 +15598,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] string[] inbufSa, nuint* inbytesleft, ref byte* outbuf, ref nuint outbytesleft) { // StringArrayOverloader @@ -15607,7 +15610,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] string[] inbufSa, ref nuint inbytesleft, string[] outbufSa, nuint* outbytesleft) { // StringArrayOverloader @@ -15622,7 +15625,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] string[] inbufSa, ref nuint inbytesleft, string[] outbufSa, ref nuint outbytesleft) { // StringArrayOverloader @@ -15637,7 +15640,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] string[] inbufSa, ref nuint inbytesleft, ref byte* outbuf, nuint* outbytesleft) { // StringArrayOverloader @@ -15649,7 +15652,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] string[] inbufSa, ref nuint inbytesleft, ref byte* outbuf, ref nuint outbytesleft) { // StringArrayOverloader @@ -15661,7 +15664,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, nuint* inbytesleft, string[] outbufSa, nuint* outbytesleft) { // StringArrayOverloader @@ -15673,7 +15676,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, nuint* inbytesleft, string[] outbufSa, ref nuint outbytesleft) { // StringArrayOverloader @@ -15685,7 +15688,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, ref nuint inbytesleft, string[] outbufSa, nuint* outbytesleft) { // StringArrayOverloader @@ -15697,7 +15700,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, ref nuint inbytesleft, string[] outbufSa, ref nuint outbytesleft) { // StringArrayOverloader @@ -15709,7 +15712,7 @@ public unsafe nuint Iconv(Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - [NativeName("Src", "Line 160, Column 34 in SDL_vulkan.h")] + [NativeName("Src", "Line 164, Column 34 in SDL_vulkan.h")] public unsafe SdlBool VulkanGetInstanceExtensions(Window* window, uint* pCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] string[] pNamesSa) { // StringArrayOverloader @@ -15721,7 +15724,7 @@ public unsafe SdlBool VulkanGetInstanceExtensions(Window* window, uint* pCount, } /// To be documented. - [NativeName("Src", "Line 160, Column 34 in SDL_vulkan.h")] + [NativeName("Src", "Line 164, Column 34 in SDL_vulkan.h")] public unsafe SdlBool VulkanGetInstanceExtensions(Window* window, ref uint pCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] string[] pNamesSa) { // StringArrayOverloader @@ -15745,7 +15748,7 @@ public unsafe int UIKitRunApp(int argc, string[] argvSa, PfnMainFunc mainFunctio } /// To be documented. - [NativeName("Src", "Line 553, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 550, Column 29 in SDL_audio.h")] public unsafe int GetDefaultAudioInfo(string[] nameSa, AudioSpec* spec, int iscapture) { // StringArrayOverloader @@ -15757,7 +15760,7 @@ public unsafe int GetDefaultAudioInfo(string[] nameSa, AudioSpec* spec, int isca } /// To be documented. - [NativeName("Src", "Line 553, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 550, Column 29 in SDL_audio.h")] public unsafe int GetDefaultAudioInfo(string[] nameSa, ref AudioSpec spec, int iscapture) { // StringArrayOverloader @@ -15769,7 +15772,7 @@ public unsafe int GetDefaultAudioInfo(string[] nameSa, ref AudioSpec spec, int i } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public unsafe AudioSpec* LoadWAVRW(RWops* src, int freesrc, AudioSpec* spec, string[] audio_bufSa, uint* audio_len) { // StringArrayOverloader @@ -15781,7 +15784,7 @@ public unsafe int GetDefaultAudioInfo(string[] nameSa, ref AudioSpec spec, int i } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public unsafe AudioSpec* LoadWAVRW(RWops* src, int freesrc, AudioSpec* spec, string[] audio_bufSa, ref uint audio_len) { // StringArrayOverloader @@ -15793,7 +15796,7 @@ public unsafe int GetDefaultAudioInfo(string[] nameSa, ref AudioSpec spec, int i } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public unsafe AudioSpec* LoadWAVRW(RWops* src, int freesrc, ref AudioSpec spec, string[] audio_bufSa, uint* audio_len) { // StringArrayOverloader @@ -15805,7 +15808,7 @@ public unsafe int GetDefaultAudioInfo(string[] nameSa, ref AudioSpec spec, int i } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public unsafe AudioSpec* LoadWAVRW(RWops* src, int freesrc, ref AudioSpec spec, string[] audio_bufSa, ref uint audio_len) { // StringArrayOverloader @@ -15817,7 +15820,7 @@ public unsafe int GetDefaultAudioInfo(string[] nameSa, ref AudioSpec spec, int i } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public unsafe AudioSpec* LoadWAVRW(ref RWops src, int freesrc, AudioSpec* spec, string[] audio_bufSa, uint* audio_len) { // StringArrayOverloader @@ -15829,7 +15832,7 @@ public unsafe int GetDefaultAudioInfo(string[] nameSa, ref AudioSpec spec, int i } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public unsafe AudioSpec* LoadWAVRW(ref RWops src, int freesrc, AudioSpec* spec, string[] audio_bufSa, ref uint audio_len) { // StringArrayOverloader @@ -15841,7 +15844,7 @@ public unsafe int GetDefaultAudioInfo(string[] nameSa, ref AudioSpec spec, int i } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public unsafe AudioSpec* LoadWAVRW(ref RWops src, int freesrc, ref AudioSpec spec, string[] audio_bufSa, uint* audio_len) { // StringArrayOverloader @@ -15853,7 +15856,7 @@ public unsafe int GetDefaultAudioInfo(string[] nameSa, ref AudioSpec spec, int i } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public unsafe AudioSpec* LoadWAVRW(ref RWops src, int freesrc, ref AudioSpec spec, string[] audio_bufSa, ref uint audio_len) { // StringArrayOverloader diff --git a/src/Windowing/Silk.NET.SDL/SdlOverloads.gen.cs b/src/Windowing/Silk.NET.SDL/SdlOverloads.gen.cs index eaafa3bb38..d6cfff20c1 100644 --- a/src/Windowing/Silk.NET.SDL/SdlOverloads.gen.cs +++ b/src/Windowing/Silk.NET.SDL/SdlOverloads.gen.cs @@ -17,7 +17,7 @@ namespace Silk.NET.SDL public static class SdlOverloads { /// To be documented. - [NativeName("Src", "Line 446, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 459, Column 31 in SDL_stdinc.h")] public static unsafe void* Realloc(this Sdl thisApi, Span mem, nuint size) where T0 : unmanaged { // SpanOverloader @@ -25,7 +25,7 @@ public static class SdlOverloads } /// To be documented. - [NativeName("Src", "Line 447, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 460, Column 30 in SDL_stdinc.h")] public static unsafe void Free(this Sdl thisApi, Span mem) where T0 : unmanaged { // SpanOverloader @@ -33,7 +33,7 @@ public static unsafe void Free(this Sdl thisApi, Span mem) where T0 : un } /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, Span free_func) { // SpanOverloader @@ -41,7 +41,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMalloc } /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, Span realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -49,7 +49,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMalloc } /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, Span realloc_func, Span free_func) { // SpanOverloader @@ -57,7 +57,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMalloc } /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, Span calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -65,7 +65,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMalloc } /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, Span calloc_func, PfnReallocFunc* realloc_func, Span free_func) { // SpanOverloader @@ -73,7 +73,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMalloc } /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, Span calloc_func, Span realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -81,7 +81,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMalloc } /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, Span calloc_func, Span realloc_func, Span free_func) { // SpanOverloader @@ -89,7 +89,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, PfnMalloc } /// To be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, Span malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -97,7 +97,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, Span malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, Span free_func) { // SpanOverloader @@ -105,7 +105,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, Span malloc_func, PfnCallocFunc* calloc_func, Span realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -113,7 +113,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, Span malloc_func, PfnCallocFunc* calloc_func, Span realloc_func, Span free_func) { // SpanOverloader @@ -121,7 +121,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, Span malloc_func, Span calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -129,7 +129,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, Span malloc_func, Span calloc_func, PfnReallocFunc* realloc_func, Span free_func) { // SpanOverloader @@ -137,7 +137,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, Span malloc_func, Span calloc_func, Span realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -145,7 +145,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 459, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 472, Column 30 in SDL_stdinc.h")] public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, Span malloc_func, Span calloc_func, Span realloc_func, Span free_func) { // SpanOverloader @@ -153,7 +153,7 @@ public static unsafe void GetOriginalMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, Span free_func) { // SpanOverloader @@ -161,7 +161,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* ma } /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, Span realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -169,7 +169,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* ma } /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, PfnCallocFunc* calloc_func, Span realloc_func, Span free_func) { // SpanOverloader @@ -177,7 +177,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* ma } /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, Span calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -185,7 +185,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* ma } /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, Span calloc_func, PfnReallocFunc* realloc_func, Span free_func) { // SpanOverloader @@ -193,7 +193,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* ma } /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, Span calloc_func, Span realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -201,7 +201,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* ma } /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* malloc_func, Span calloc_func, Span realloc_func, Span free_func) { // SpanOverloader @@ -209,7 +209,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, PfnMallocFunc* ma } /// To be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, Span malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -217,7 +217,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, Span malloc_func, PfnCallocFunc* calloc_func, PfnReallocFunc* realloc_func, Span free_func) { // SpanOverloader @@ -225,7 +225,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, Span malloc_func, PfnCallocFunc* calloc_func, Span realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -233,7 +233,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, Span malloc_func, PfnCallocFunc* calloc_func, Span realloc_func, Span free_func) { // SpanOverloader @@ -241,7 +241,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, Span malloc_func, Span calloc_func, PfnReallocFunc* realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -249,7 +249,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, Span malloc_func, Span calloc_func, PfnReallocFunc* realloc_func, Span free_func) { // SpanOverloader @@ -257,7 +257,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, Span malloc_func, Span calloc_func, Span realloc_func, PfnFreeFunc* free_func) { // SpanOverloader @@ -265,7 +265,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 469, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 482, Column 30 in SDL_stdinc.h")] public static unsafe void GetMemoryFunctions(this Sdl thisApi, Span malloc_func, Span calloc_func, Span realloc_func, Span free_func) { // SpanOverloader @@ -273,7 +273,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 491, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 504, Column 31 in SDL_stdinc.h")] public static unsafe byte* Getenv(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name) { // SpanOverloader @@ -281,7 +281,7 @@ public static unsafe void GetMemoryFunctions(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] public static unsafe int Setenv(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan value, int overwrite) { // SpanOverloader @@ -289,7 +289,7 @@ public static unsafe int Setenv(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] public static unsafe int Setenv(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value, int overwrite) { // SpanOverloader @@ -297,7 +297,7 @@ public static unsafe int Setenv(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] public static unsafe int Setenv(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan value, int overwrite) { // SpanOverloader @@ -305,7 +305,7 @@ public static unsafe int Setenv(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] public static unsafe int Setenv(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value, int overwrite) { // SpanOverloader @@ -313,7 +313,7 @@ public static unsafe int Setenv(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 492, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_stdinc.h")] public static unsafe int Setenv(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan value, int overwrite) { // SpanOverloader @@ -321,39 +321,39 @@ public static unsafe int Setenv(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 494, Column 30 in SDL_stdinc.h")] - public static unsafe void Qsort(this Sdl thisApi, Span @base, nuint nmemb, nuint size, PfnVvVvI compare) where T0 : unmanaged + [NativeName("Src", "Line 508, Column 30 in SDL_stdinc.h")] + public static unsafe void Qsort(this Sdl thisApi, Span @base, nuint nmemb, nuint size, PfnCompareCallback compare) where T0 : unmanaged { // SpanOverloader thisApi.Qsort(ref @base.GetPinnableReference(), nmemb, size, compare); } /// To be documented. - [NativeName("Src", "Line 495, Column 32 in SDL_stdinc.h")] - public static unsafe void* Bsearch(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan @base, nuint nmemb, nuint size, PfnVvVvI compare) where T0 : unmanaged + [NativeName("Src", "Line 509, Column 32 in SDL_stdinc.h")] + public static unsafe void* Bsearch(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan @base, nuint nmemb, nuint size, PfnCompareCallback compare) where T0 : unmanaged { // SpanOverloader return thisApi.Bsearch(key, in @base.GetPinnableReference(), nmemb, size, compare); } /// To be documented. - [NativeName("Src", "Line 495, Column 32 in SDL_stdinc.h")] - public static unsafe void* Bsearch(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* @base, nuint nmemb, nuint size, PfnVvVvI compare) where T0 : unmanaged + [NativeName("Src", "Line 509, Column 32 in SDL_stdinc.h")] + public static unsafe void* Bsearch(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* @base, nuint nmemb, nuint size, PfnCompareCallback compare) where T0 : unmanaged { // SpanOverloader return thisApi.Bsearch(in key.GetPinnableReference(), @base, nmemb, size, compare); } /// To be documented. - [NativeName("Src", "Line 495, Column 32 in SDL_stdinc.h")] - public static unsafe void* Bsearch(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan @base, nuint nmemb, nuint size, PfnVvVvI compare) where T0 : unmanaged where T1 : unmanaged + [NativeName("Src", "Line 509, Column 32 in SDL_stdinc.h")] + public static unsafe void* Bsearch(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan key, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan @base, nuint nmemb, nuint size, PfnCompareCallback compare) where T0 : unmanaged where T1 : unmanaged { // SpanOverloader return thisApi.Bsearch(in key.GetPinnableReference(), in @base.GetPinnableReference(), nmemb, size, compare); } /// To be documented. - [NativeName("Src", "Line 519, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 533, Column 32 in SDL_stdinc.h")] public static unsafe ushort Crc16(this Sdl thisApi, ushort crc, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint len) where T0 : unmanaged { // SpanOverloader @@ -361,7 +361,7 @@ public static unsafe ushort Crc16(this Sdl thisApi, ushort crc, [Flow(Silk.N } /// To be documented. - [NativeName("Src", "Line 520, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 534, Column 32 in SDL_stdinc.h")] public static unsafe uint Crc32(this Sdl thisApi, uint crc, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint len) where T0 : unmanaged { // SpanOverloader @@ -369,7 +369,7 @@ public static unsafe uint Crc32(this Sdl thisApi, uint crc, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 522, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 536, Column 31 in SDL_stdinc.h")] public static unsafe void* Memset(this Sdl thisApi, Span dst, int c, nuint len) where T0 : unmanaged { // SpanOverloader @@ -377,7 +377,7 @@ public static unsafe uint Crc32(this Sdl thisApi, uint crc, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 562, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 577, Column 31 in SDL_stdinc.h")] public static unsafe void* Memcpy(this Sdl thisApi, void* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint len) where T0 : unmanaged { // SpanOverloader @@ -385,7 +385,7 @@ public static unsafe uint Crc32(this Sdl thisApi, uint crc, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 562, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 577, Column 31 in SDL_stdinc.h")] public static unsafe void* Memcpy(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, nuint len) where T0 : unmanaged { // SpanOverloader @@ -393,7 +393,7 @@ public static unsafe uint Crc32(this Sdl thisApi, uint crc, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 562, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 577, Column 31 in SDL_stdinc.h")] public static unsafe void* Memcpy(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint len) where T0 : unmanaged where T1 : unmanaged { // SpanOverloader @@ -401,7 +401,7 @@ public static unsafe uint Crc32(this Sdl thisApi, uint crc, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 564, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 579, Column 31 in SDL_stdinc.h")] public static unsafe void* Memmove(this Sdl thisApi, void* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint len) where T0 : unmanaged { // SpanOverloader @@ -409,7 +409,7 @@ public static unsafe uint Crc32(this Sdl thisApi, uint crc, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 564, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 579, Column 31 in SDL_stdinc.h")] public static unsafe void* Memmove(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, nuint len) where T0 : unmanaged { // SpanOverloader @@ -417,7 +417,7 @@ public static unsafe uint Crc32(this Sdl thisApi, uint crc, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 564, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 579, Column 31 in SDL_stdinc.h")] public static unsafe void* Memmove(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint len) where T0 : unmanaged where T1 : unmanaged { // SpanOverloader @@ -425,7 +425,7 @@ public static unsafe uint Crc32(this Sdl thisApi, uint crc, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 565, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 580, Column 29 in SDL_stdinc.h")] public static unsafe int Memcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan s2, nuint len) where T0 : unmanaged { // SpanOverloader @@ -433,7 +433,7 @@ public static unsafe int Memcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 565, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 580, Column 29 in SDL_stdinc.h")] public static unsafe int Memcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* s2, nuint len) where T0 : unmanaged { // SpanOverloader @@ -441,7 +441,7 @@ public static unsafe int Memcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 565, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 580, Column 29 in SDL_stdinc.h")] public static unsafe int Memcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan s2, nuint len) where T0 : unmanaged where T1 : unmanaged { // SpanOverloader @@ -449,7 +449,7 @@ public static unsafe int Memcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Na } /// To be documented. - [NativeName("Src", "Line 567, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 582, Column 32 in SDL_stdinc.h")] public static unsafe nuint Wcslen(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wstr) { // SpanOverloader @@ -457,7 +457,7 @@ public static unsafe nuint Wcslen(this Sdl thisApi, [Flow(Silk.NET.Core.Native.F } /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] public static unsafe nuint Wcslcpy(this Sdl thisApi, char* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -465,7 +465,7 @@ public static unsafe nuint Wcslcpy(this Sdl thisApi, char* dst, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] public static unsafe nuint Wcslcpy(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* src, nuint maxlen) { // SpanOverloader @@ -473,7 +473,7 @@ public static unsafe nuint Wcslcpy(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] public static unsafe nuint Wcslcpy(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -481,7 +481,7 @@ public static unsafe nuint Wcslcpy(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] public static unsafe nuint Wcslcpy(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen) { // SpanOverloader @@ -489,7 +489,7 @@ public static unsafe nuint Wcslcpy(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 568, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 583, Column 32 in SDL_stdinc.h")] public static unsafe nuint Wcslcpy(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -497,7 +497,7 @@ public static unsafe nuint Wcslcpy(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] public static unsafe nuint Wcslcat(this Sdl thisApi, char* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -505,7 +505,7 @@ public static unsafe nuint Wcslcat(this Sdl thisApi, char* dst, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] public static unsafe nuint Wcslcat(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* src, nuint maxlen) { // SpanOverloader @@ -513,7 +513,7 @@ public static unsafe nuint Wcslcat(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] public static unsafe nuint Wcslcat(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -521,7 +521,7 @@ public static unsafe nuint Wcslcat(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] public static unsafe nuint Wcslcat(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen) { // SpanOverloader @@ -529,7 +529,7 @@ public static unsafe nuint Wcslcat(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 569, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 584, Column 32 in SDL_stdinc.h")] public static unsafe nuint Wcslcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -537,7 +537,7 @@ public static unsafe nuint Wcslcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 570, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 585, Column 34 in SDL_stdinc.h")] public static unsafe char* Wcsdup(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wstr) { // SpanOverloader @@ -545,7 +545,7 @@ public static unsafe nuint Wcslcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] public static unsafe char* Wcsstr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan needle) { // SpanOverloader @@ -553,7 +553,7 @@ public static unsafe nuint Wcslcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] public static unsafe char* Wcsstr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* needle) { // SpanOverloader @@ -561,7 +561,7 @@ public static unsafe nuint Wcslcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] public static unsafe char* Wcsstr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan needle) { // SpanOverloader @@ -569,7 +569,7 @@ public static unsafe nuint Wcslcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] public static unsafe char* Wcsstr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle) { // SpanOverloader @@ -577,7 +577,7 @@ public static unsafe nuint Wcslcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 571, Column 34 in SDL_stdinc.h")] + [NativeName("Src", "Line 586, Column 34 in SDL_stdinc.h")] public static unsafe char* Wcsstr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan needle) { // SpanOverloader @@ -585,7 +585,7 @@ public static unsafe nuint Wcslcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] public static unsafe int Wcscmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -593,7 +593,7 @@ public static unsafe int Wcscmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] public static unsafe int Wcscmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2) { // SpanOverloader @@ -601,7 +601,7 @@ public static unsafe int Wcscmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] public static unsafe int Wcscmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -609,7 +609,7 @@ public static unsafe int Wcscmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] public static unsafe int Wcscmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2) { // SpanOverloader @@ -617,7 +617,7 @@ public static unsafe int Wcscmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 588, Column 29 in SDL_stdinc.h")] public static unsafe int Wcscmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -625,7 +625,7 @@ public static unsafe int Wcscmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] public static unsafe int Wcsncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint maxlen) { // SpanOverloader @@ -633,7 +633,7 @@ public static unsafe int Wcsncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] public static unsafe int Wcsncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2, nuint maxlen) { // SpanOverloader @@ -641,7 +641,7 @@ public static unsafe int Wcsncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] public static unsafe int Wcsncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint maxlen) { // SpanOverloader @@ -649,7 +649,7 @@ public static unsafe int Wcsncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] public static unsafe int Wcsncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint maxlen) { // SpanOverloader @@ -657,7 +657,7 @@ public static unsafe int Wcsncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 574, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 589, Column 29 in SDL_stdinc.h")] public static unsafe int Wcsncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint maxlen) { // SpanOverloader @@ -665,7 +665,7 @@ public static unsafe int Wcsncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] public static unsafe int Wcscasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -673,7 +673,7 @@ public static unsafe int Wcscasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] public static unsafe int Wcscasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2) { // SpanOverloader @@ -681,7 +681,7 @@ public static unsafe int Wcscasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] public static unsafe int Wcscasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -689,7 +689,7 @@ public static unsafe int Wcscasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] public static unsafe int Wcscasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2) { // SpanOverloader @@ -697,7 +697,7 @@ public static unsafe int Wcscasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 575, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 590, Column 29 in SDL_stdinc.h")] public static unsafe int Wcscasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -705,7 +705,7 @@ public static unsafe int Wcscasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] public static unsafe int Wcsncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint len) { // SpanOverloader @@ -713,7 +713,7 @@ public static unsafe int Wcsncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] public static unsafe int Wcsncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* str2, nuint len) { // SpanOverloader @@ -721,7 +721,7 @@ public static unsafe int Wcsncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] public static unsafe int Wcsncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint len) { // SpanOverloader @@ -729,7 +729,7 @@ public static unsafe int Wcsncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] public static unsafe int Wcsncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint len) { // SpanOverloader @@ -737,7 +737,7 @@ public static unsafe int Wcsncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 576, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 591, Column 29 in SDL_stdinc.h")] public static unsafe int Wcsncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint len) { // SpanOverloader @@ -745,7 +745,7 @@ public static unsafe int Wcsncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 578, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 593, Column 32 in SDL_stdinc.h")] public static unsafe nuint Strlen(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str) { // SpanOverloader @@ -753,7 +753,7 @@ public static unsafe nuint Strlen(this Sdl thisApi, [Flow(Silk.NET.Core.Native.F } /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] public static unsafe nuint Strlcpy(this Sdl thisApi, byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -761,7 +761,7 @@ public static unsafe nuint Strlcpy(this Sdl thisApi, byte* dst, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] public static unsafe nuint Strlcpy(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint maxlen) { // SpanOverloader @@ -769,7 +769,7 @@ public static unsafe nuint Strlcpy(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] public static unsafe nuint Strlcpy(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -777,7 +777,7 @@ public static unsafe nuint Strlcpy(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] public static unsafe nuint Strlcpy(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen) { // SpanOverloader @@ -785,7 +785,7 @@ public static unsafe nuint Strlcpy(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 579, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 594, Column 32 in SDL_stdinc.h")] public static unsafe nuint Strlcpy(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -793,7 +793,7 @@ public static unsafe nuint Strlcpy(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] public static unsafe nuint Utf8strlcpy(this Sdl thisApi, byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint dst_bytes) { // SpanOverloader @@ -801,7 +801,7 @@ public static unsafe nuint Utf8strlcpy(this Sdl thisApi, byte* dst, [Flow(Silk.N } /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] public static unsafe nuint Utf8strlcpy(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint dst_bytes) { // SpanOverloader @@ -809,7 +809,7 @@ public static unsafe nuint Utf8strlcpy(this Sdl thisApi, Span dst, [Flow(S } /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] public static unsafe nuint Utf8strlcpy(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint dst_bytes) { // SpanOverloader @@ -817,7 +817,7 @@ public static unsafe nuint Utf8strlcpy(this Sdl thisApi, Span dst, [Flow(S } /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] public static unsafe nuint Utf8strlcpy(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint dst_bytes) { // SpanOverloader @@ -825,7 +825,7 @@ public static unsafe nuint Utf8strlcpy(this Sdl thisApi, Span dst, [Flow(S } /// To be documented. - [NativeName("Src", "Line 580, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 595, Column 32 in SDL_stdinc.h")] public static unsafe nuint Utf8strlcpy(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint dst_bytes) { // SpanOverloader @@ -833,7 +833,7 @@ public static unsafe nuint Utf8strlcpy(this Sdl thisApi, [UnmanagedType(Silk.NET } /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] public static unsafe nuint Strlcat(this Sdl thisApi, byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -841,7 +841,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, byte* dst, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] public static unsafe nuint Strlcat(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, nuint maxlen) { // SpanOverloader @@ -849,7 +849,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] public static unsafe nuint Strlcat(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -857,7 +857,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] public static unsafe nuint Strlcat(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, nuint maxlen) { // SpanOverloader @@ -865,7 +865,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 581, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 596, Column 32 in SDL_stdinc.h")] public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, nuint maxlen) { // SpanOverloader @@ -873,7 +873,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 582, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strdup(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str) { // SpanOverloader @@ -881,7 +881,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 583, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strrev(this Sdl thisApi, Span str) { // SpanOverloader @@ -889,7 +889,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 584, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strupr(this Sdl thisApi, Span str) { // SpanOverloader @@ -897,7 +897,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 585, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 600, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strlwr(this Sdl thisApi, Span str) { // SpanOverloader @@ -905,7 +905,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 586, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 601, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strchr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, int c) { // SpanOverloader @@ -913,7 +913,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 587, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 602, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strrchr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, int c) { // SpanOverloader @@ -921,7 +921,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strstr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan needle) { // SpanOverloader @@ -929,7 +929,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strstr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle) { // SpanOverloader @@ -937,7 +937,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strstr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan needle) { // SpanOverloader @@ -945,7 +945,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strstr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle) { // SpanOverloader @@ -953,7 +953,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 588, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 603, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strstr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan needle) { // SpanOverloader @@ -961,7 +961,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strcasestr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan needle) { // SpanOverloader @@ -969,7 +969,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strcasestr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* needle) { // SpanOverloader @@ -977,7 +977,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strcasestr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan needle) { // SpanOverloader @@ -985,7 +985,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strcasestr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string needle) { // SpanOverloader @@ -993,7 +993,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 589, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 604, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strcasestr(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string haystack, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan needle) { // SpanOverloader @@ -1001,7 +1001,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strtokr(this Sdl thisApi, byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan s2, byte** saveptr) { // SpanOverloader @@ -1009,7 +1009,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strtokr(this Sdl thisApi, byte* s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan s2, ref byte* saveptr) { // SpanOverloader @@ -1017,7 +1017,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strtokr(this Sdl thisApi, Span s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, byte** saveptr) { // SpanOverloader @@ -1025,7 +1025,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strtokr(this Sdl thisApi, Span s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* s2, ref byte* saveptr) { // SpanOverloader @@ -1033,7 +1033,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strtokr(this Sdl thisApi, Span s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan s2, byte** saveptr) { // SpanOverloader @@ -1041,7 +1041,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strtokr(this Sdl thisApi, Span s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan s2, ref byte* saveptr) { // SpanOverloader @@ -1049,7 +1049,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strtokr(this Sdl thisApi, Span s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, byte** saveptr) { // SpanOverloader @@ -1057,7 +1057,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strtokr(this Sdl thisApi, Span s1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s2, ref byte* saveptr) { // SpanOverloader @@ -1065,7 +1065,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strtokr(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan s2, byte** saveptr) { // SpanOverloader @@ -1073,7 +1073,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 590, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 605, Column 31 in SDL_stdinc.h")] public static unsafe byte* Strtokr(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string s1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan s2, ref byte* saveptr) { // SpanOverloader @@ -1081,7 +1081,7 @@ public static unsafe nuint Strlcat(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 591, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] public static unsafe nuint Utf8strlen(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str) { // SpanOverloader @@ -1089,7 +1089,7 @@ public static unsafe nuint Utf8strlen(this Sdl thisApi, [Flow(Silk.NET.Core.Nati } /// To be documented. - [NativeName("Src", "Line 592, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] public static unsafe nuint Utf8strnlen(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, nuint bytes) { // SpanOverloader @@ -1097,7 +1097,7 @@ public static unsafe nuint Utf8strnlen(this Sdl thisApi, [Flow(Silk.NET.Core.Nat } /// To be documented. - [NativeName("Src", "Line 594, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 609, Column 31 in SDL_stdinc.h")] public static unsafe byte* Itoa(this Sdl thisApi, int value, Span str, int radix) { // SpanOverloader @@ -1105,7 +1105,7 @@ public static unsafe nuint Utf8strnlen(this Sdl thisApi, [Flow(Silk.NET.Core.Nat } /// To be documented. - [NativeName("Src", "Line 595, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 610, Column 31 in SDL_stdinc.h")] public static unsafe byte* Uitoa(this Sdl thisApi, uint value, Span str, int radix) { // SpanOverloader @@ -1113,7 +1113,7 @@ public static unsafe nuint Utf8strnlen(this Sdl thisApi, [Flow(Silk.NET.Core.Nat } /// To be documented. - [NativeName("Src", "Line 596, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 611, Column 31 in SDL_stdinc.h")] public static unsafe byte* Ltoa(this Sdl thisApi, int value, Span str, int radix) { // SpanOverloader @@ -1121,7 +1121,7 @@ public static unsafe nuint Utf8strnlen(this Sdl thisApi, [Flow(Silk.NET.Core.Nat } /// To be documented. - [NativeName("Src", "Line 597, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 612, Column 31 in SDL_stdinc.h")] public static unsafe byte* Ultoa(this Sdl thisApi, uint value, Span str, int radix) { // SpanOverloader @@ -1129,7 +1129,7 @@ public static unsafe nuint Utf8strnlen(this Sdl thisApi, [Flow(Silk.NET.Core.Nat } /// To be documented. - [NativeName("Src", "Line 598, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 613, Column 31 in SDL_stdinc.h")] public static unsafe byte* Lltoa(this Sdl thisApi, long value, Span str, int radix) { // SpanOverloader @@ -1137,7 +1137,7 @@ public static unsafe nuint Utf8strnlen(this Sdl thisApi, [Flow(Silk.NET.Core.Nat } /// To be documented. - [NativeName("Src", "Line 599, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 614, Column 31 in SDL_stdinc.h")] public static unsafe byte* Ulltoa(this Sdl thisApi, ulong value, Span str, int radix) { // SpanOverloader @@ -1145,7 +1145,7 @@ public static unsafe nuint Utf8strnlen(this Sdl thisApi, [Flow(Silk.NET.Core.Nat } /// To be documented. - [NativeName("Src", "Line 601, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] public static unsafe int Atoi(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str) { // SpanOverloader @@ -1153,7 +1153,7 @@ public static unsafe int Atoi(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowD } /// To be documented. - [NativeName("Src", "Line 602, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 617, Column 32 in SDL_stdinc.h")] public static unsafe double Atof(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str) { // SpanOverloader @@ -1161,7 +1161,7 @@ public static unsafe double Atof(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 603, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 618, Column 30 in SDL_stdinc.h")] public static unsafe int Strtol(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, byte** endp, int @base) { // SpanOverloader @@ -1169,7 +1169,7 @@ public static unsafe int Strtol(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 603, Column 30 in SDL_stdinc.h")] + [NativeName("Src", "Line 618, Column 30 in SDL_stdinc.h")] public static unsafe int Strtol(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, ref byte* endp, int @base) { // SpanOverloader @@ -1177,7 +1177,7 @@ public static unsafe int Strtol(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 604, Column 39 in SDL_stdinc.h")] + [NativeName("Src", "Line 619, Column 39 in SDL_stdinc.h")] public static unsafe uint Strtoul(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, byte** endp, int @base) { // SpanOverloader @@ -1185,7 +1185,7 @@ public static unsafe uint Strtoul(this Sdl thisApi, [Flow(Silk.NET.Core.Native.F } /// To be documented. - [NativeName("Src", "Line 604, Column 39 in SDL_stdinc.h")] + [NativeName("Src", "Line 619, Column 39 in SDL_stdinc.h")] public static unsafe uint Strtoul(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, ref byte* endp, int @base) { // SpanOverloader @@ -1193,7 +1193,7 @@ public static unsafe uint Strtoul(this Sdl thisApi, [Flow(Silk.NET.Core.Native.F } /// To be documented. - [NativeName("Src", "Line 605, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 620, Column 32 in SDL_stdinc.h")] public static unsafe long Strtoll(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, byte** endp, int @base) { // SpanOverloader @@ -1201,7 +1201,7 @@ public static unsafe long Strtoll(this Sdl thisApi, [Flow(Silk.NET.Core.Native.F } /// To be documented. - [NativeName("Src", "Line 605, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 620, Column 32 in SDL_stdinc.h")] public static unsafe long Strtoll(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, ref byte* endp, int @base) { // SpanOverloader @@ -1209,7 +1209,7 @@ public static unsafe long Strtoll(this Sdl thisApi, [Flow(Silk.NET.Core.Native.F } /// To be documented. - [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 621, Column 32 in SDL_stdinc.h")] public static unsafe ulong Strtoull(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, byte** endp, int @base) { // SpanOverloader @@ -1217,7 +1217,7 @@ public static unsafe ulong Strtoull(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 606, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 621, Column 32 in SDL_stdinc.h")] public static unsafe ulong Strtoull(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, ref byte* endp, int @base) { // SpanOverloader @@ -1225,7 +1225,7 @@ public static unsafe ulong Strtoull(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 622, Column 32 in SDL_stdinc.h")] public static unsafe double Strtod(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, byte** endp) { // SpanOverloader @@ -1233,7 +1233,7 @@ public static unsafe double Strtod(this Sdl thisApi, [Flow(Silk.NET.Core.Native. } /// To be documented. - [NativeName("Src", "Line 607, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 622, Column 32 in SDL_stdinc.h")] public static unsafe double Strtod(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str, ref byte* endp) { // SpanOverloader @@ -1241,7 +1241,7 @@ public static unsafe double Strtod(this Sdl thisApi, [Flow(Silk.NET.Core.Native. } /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] public static unsafe int Strcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -1249,7 +1249,7 @@ public static unsafe int Strcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] public static unsafe int Strcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2) { // SpanOverloader @@ -1257,7 +1257,7 @@ public static unsafe int Strcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] public static unsafe int Strcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -1265,7 +1265,7 @@ public static unsafe int Strcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] public static unsafe int Strcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2) { // SpanOverloader @@ -1273,7 +1273,7 @@ public static unsafe int Strcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 609, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 624, Column 29 in SDL_stdinc.h")] public static unsafe int Strcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -1281,7 +1281,7 @@ public static unsafe int Strcmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] public static unsafe int Strncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint maxlen) { // SpanOverloader @@ -1289,7 +1289,7 @@ public static unsafe int Strncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] public static unsafe int Strncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2, nuint maxlen) { // SpanOverloader @@ -1297,7 +1297,7 @@ public static unsafe int Strncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] public static unsafe int Strncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint maxlen) { // SpanOverloader @@ -1305,7 +1305,7 @@ public static unsafe int Strncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] public static unsafe int Strncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint maxlen) { // SpanOverloader @@ -1313,7 +1313,7 @@ public static unsafe int Strncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 610, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 625, Column 29 in SDL_stdinc.h")] public static unsafe int Strncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint maxlen) { // SpanOverloader @@ -1321,7 +1321,7 @@ public static unsafe int Strncmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] public static unsafe int Strcasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -1329,7 +1329,7 @@ public static unsafe int Strcasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] public static unsafe int Strcasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2) { // SpanOverloader @@ -1337,7 +1337,7 @@ public static unsafe int Strcasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] public static unsafe int Strcasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -1345,7 +1345,7 @@ public static unsafe int Strcasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] public static unsafe int Strcasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2) { // SpanOverloader @@ -1353,7 +1353,7 @@ public static unsafe int Strcasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 611, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 626, Column 29 in SDL_stdinc.h")] public static unsafe int Strcasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2) { // SpanOverloader @@ -1361,7 +1361,7 @@ public static unsafe int Strcasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native } /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] public static unsafe int Strncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint len) { // SpanOverloader @@ -1369,7 +1369,7 @@ public static unsafe int Strncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] public static unsafe int Strncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* str2, nuint len) { // SpanOverloader @@ -1377,7 +1377,7 @@ public static unsafe int Strncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] public static unsafe int Strncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint len) { // SpanOverloader @@ -1385,7 +1385,7 @@ public static unsafe int Strncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] public static unsafe int Strncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str2, nuint len) { // SpanOverloader @@ -1393,7 +1393,7 @@ public static unsafe int Strncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 612, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 627, Column 29 in SDL_stdinc.h")] public static unsafe int Strncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string str1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str2, nuint len) { // SpanOverloader @@ -1401,7 +1401,7 @@ public static unsafe int Strncasecmp(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] public static unsafe int Sscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt) { // SpanOverloader @@ -1409,7 +1409,7 @@ public static unsafe int Sscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] public static unsafe int Sscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt) { // SpanOverloader @@ -1417,7 +1417,7 @@ public static unsafe int Sscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] public static unsafe int Sscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt) { // SpanOverloader @@ -1425,7 +1425,7 @@ public static unsafe int Sscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] public static unsafe int Sscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt) { // SpanOverloader @@ -1433,7 +1433,7 @@ public static unsafe int Sscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 614, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_stdinc.h")] public static unsafe int Sscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt) { // SpanOverloader @@ -1441,7 +1441,7 @@ public static unsafe int Sscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Flo } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, Span ap) { // SpanOverloader @@ -1449,7 +1449,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, byte* ap) { // SpanOverloader @@ -1457,7 +1457,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, Span ap) { // SpanOverloader @@ -1465,7 +1465,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1473,7 +1473,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, Span ap) { // SpanOverloader @@ -1481,7 +1481,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, byte* ap) { // SpanOverloader @@ -1489,7 +1489,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, Span ap) { // SpanOverloader @@ -1497,7 +1497,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1505,7 +1505,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, byte* ap) { // SpanOverloader @@ -1513,7 +1513,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, Span ap) { // SpanOverloader @@ -1521,7 +1521,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1529,7 +1529,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, byte* ap) { // SpanOverloader @@ -1537,7 +1537,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, Span ap) { // SpanOverloader @@ -1545,7 +1545,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1553,7 +1553,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, Span ap) { // SpanOverloader @@ -1561,7 +1561,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, byte* ap) { // SpanOverloader @@ -1569,7 +1569,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, Span ap) { // SpanOverloader @@ -1577,7 +1577,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1585,7 +1585,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 615, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 630, Column 29 in SDL_stdinc.h")] public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, Span ap) { // SpanOverloader @@ -1593,7 +1593,7 @@ public static unsafe int Vsscanf(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] public static unsafe int Snprintf(this Sdl thisApi, byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt) { // SpanOverloader @@ -1601,7 +1601,7 @@ public static unsafe int Snprintf(this Sdl thisApi, byte* text, nuint maxlen, [F } /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] public static unsafe int Snprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt) { // SpanOverloader @@ -1609,7 +1609,7 @@ public static unsafe int Snprintf(this Sdl thisApi, Span text, nuint maxle } /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] public static unsafe int Snprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt) { // SpanOverloader @@ -1617,7 +1617,7 @@ public static unsafe int Snprintf(this Sdl thisApi, Span text, nuint maxle } /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] public static unsafe int Snprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt) { // SpanOverloader @@ -1625,7 +1625,7 @@ public static unsafe int Snprintf(this Sdl thisApi, Span text, nuint maxle } /// To be documented. - [NativeName("Src", "Line 616, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 631, Column 29 in SDL_stdinc.h")] public static unsafe int Snprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt) { // SpanOverloader @@ -1633,7 +1633,7 @@ public static unsafe int Snprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, Span ap) { // SpanOverloader @@ -1641,7 +1641,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, byte* text, nuint maxlen, [ } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, byte* ap) { // SpanOverloader @@ -1649,7 +1649,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, byte* text, nuint maxlen, [ } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, Span ap) { // SpanOverloader @@ -1657,7 +1657,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, byte* text, nuint maxlen, [ } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1665,7 +1665,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, byte* text, nuint maxlen, [ } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, byte* text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, Span ap) { // SpanOverloader @@ -1673,7 +1673,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, byte* text, nuint maxlen, [ } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, byte* ap) { // SpanOverloader @@ -1681,7 +1681,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxl } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, Span ap) { // SpanOverloader @@ -1689,7 +1689,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxl } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1697,7 +1697,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxl } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, byte* ap) { // SpanOverloader @@ -1705,7 +1705,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxl } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, Span ap) { // SpanOverloader @@ -1713,7 +1713,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxl } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1721,7 +1721,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxl } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, byte* ap) { // SpanOverloader @@ -1729,7 +1729,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxl } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, Span ap) { // SpanOverloader @@ -1737,7 +1737,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxl } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1745,7 +1745,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, Span text, nuint maxl } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, Span ap) { // SpanOverloader @@ -1753,7 +1753,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, byte* ap) { // SpanOverloader @@ -1761,7 +1761,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, Span ap) { // SpanOverloader @@ -1769,7 +1769,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1777,7 +1777,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 617, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 632, Column 29 in SDL_stdinc.h")] public static unsafe int Vsnprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string text, nuint maxlen, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, Span ap) { // SpanOverloader @@ -1785,7 +1785,7 @@ public static unsafe int Vsnprintf(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 618, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 633, Column 29 in SDL_stdinc.h")] public static unsafe int Asprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt) { // SpanOverloader @@ -1793,7 +1793,7 @@ public static unsafe int Asprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET. } /// To be documented. - [NativeName("Src", "Line 618, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 633, Column 29 in SDL_stdinc.h")] public static unsafe int Asprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt) { // SpanOverloader @@ -1801,7 +1801,7 @@ public static unsafe int Asprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk.N } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public static unsafe int Vasprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, Span ap) { // SpanOverloader @@ -1809,7 +1809,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public static unsafe int Vasprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, byte* ap) { // SpanOverloader @@ -1817,7 +1817,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public static unsafe int Vasprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, Span ap) { // SpanOverloader @@ -1825,7 +1825,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public static unsafe int Vasprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1833,7 +1833,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public static unsafe int Vasprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, Span ap) { // SpanOverloader @@ -1841,7 +1841,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, byte** strp, [Flow(Silk.NET } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fmt, Span ap) { // SpanOverloader @@ -1849,7 +1849,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, byte* ap) { // SpanOverloader @@ -1857,7 +1857,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, Span ap) { // SpanOverloader @@ -1865,7 +1865,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string ap) { // SpanOverloader @@ -1873,7 +1873,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 619, Column 29 in SDL_stdinc.h")] + [NativeName("Src", "Line 634, Column 29 in SDL_stdinc.h")] public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fmt, Span ap) { // SpanOverloader @@ -1881,7 +1881,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] public static unsafe Icon* IconvOpen(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode) { // SpanOverloader @@ -1889,7 +1889,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] public static unsafe Icon* IconvOpen(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode) { // SpanOverloader @@ -1897,7 +1897,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] public static unsafe Icon* IconvOpen(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode) { // SpanOverloader @@ -1905,7 +1905,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] public static unsafe Icon* IconvOpen(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode) { // SpanOverloader @@ -1913,7 +1913,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 692, Column 37 in SDL_stdinc.h")] + [NativeName("Src", "Line 707, Column 37 in SDL_stdinc.h")] public static unsafe Icon* IconvOpen(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode) { // SpanOverloader @@ -1921,7 +1921,7 @@ public static unsafe int Vasprintf(this Sdl thisApi, ref byte* strp, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, nuint* inbytesleft, byte** outbuf, Span outbytesleft) { // SpanOverloader @@ -1929,7 +1929,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, nuint* inbytesleft, ref byte* outbuf, Span outbytesleft) { // SpanOverloader @@ -1937,7 +1937,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, Span inbytesleft, byte** outbuf, nuint* outbytesleft) { // SpanOverloader @@ -1945,7 +1945,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, Span inbytesleft, byte** outbuf, Span outbytesleft) { // SpanOverloader @@ -1953,7 +1953,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, Span inbytesleft, ref byte* outbuf, nuint* outbytesleft) { // SpanOverloader @@ -1961,7 +1961,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** inbuf, Span inbytesleft, ref byte* outbuf, Span outbytesleft) { // SpanOverloader @@ -1969,7 +1969,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, nuint* inbytesleft, byte** outbuf, Span outbytesleft) { // SpanOverloader @@ -1977,7 +1977,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, nuint* inbytesleft, ref byte* outbuf, Span outbytesleft) { // SpanOverloader @@ -1985,7 +1985,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, Span inbytesleft, byte** outbuf, nuint* outbytesleft) { // SpanOverloader @@ -1993,7 +1993,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, Span inbytesleft, byte** outbuf, Span outbytesleft) { // SpanOverloader @@ -2001,7 +2001,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, Span inbytesleft, ref byte* outbuf, nuint* outbytesleft) { // SpanOverloader @@ -2009,7 +2009,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 695, Column 32 in SDL_stdinc.h")] + [NativeName("Src", "Line 710, Column 32 in SDL_stdinc.h")] public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* inbuf, Span inbytesleft, ref byte* outbuf, Span outbytesleft) { // SpanOverloader @@ -2017,7 +2017,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan inbuf, nuint inbytesleft) { // SpanOverloader @@ -2025,7 +2025,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft) { // SpanOverloader @@ -2033,7 +2033,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan inbuf, nuint inbytesleft) { // SpanOverloader @@ -2041,7 +2041,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft) { // SpanOverloader @@ -2049,7 +2049,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan inbuf, nuint inbytesleft) { // SpanOverloader @@ -2057,7 +2057,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft) { // SpanOverloader @@ -2065,7 +2065,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan inbuf, nuint inbytesleft) { // SpanOverloader @@ -2073,7 +2073,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft) { // SpanOverloader @@ -2081,7 +2081,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft) { // SpanOverloader @@ -2089,7 +2089,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan inbuf, nuint inbytesleft) { // SpanOverloader @@ -2097,7 +2097,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft) { // SpanOverloader @@ -2105,7 +2105,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft) { // SpanOverloader @@ -2113,7 +2113,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan inbuf, nuint inbytesleft) { // SpanOverloader @@ -2121,7 +2121,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft) { // SpanOverloader @@ -2129,7 +2129,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan inbuf, nuint inbytesleft) { // SpanOverloader @@ -2137,7 +2137,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* inbuf, nuint inbytesleft) { // SpanOverloader @@ -2145,7 +2145,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan inbuf, nuint inbytesleft) { // SpanOverloader @@ -2153,7 +2153,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string inbuf, nuint inbytesleft) { // SpanOverloader @@ -2161,7 +2161,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 705, Column 31 in SDL_stdinc.h")] + [NativeName("Src", "Line 720, Column 31 in SDL_stdinc.h")] public static unsafe byte* IconvString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string tocode, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string fromcode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan inbuf, nuint inbytesleft) { // SpanOverloader @@ -2169,7 +2169,7 @@ public static unsafe nuint Iconv(this Sdl thisApi, Icon* cd, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, uint* Rmask, uint* Gmask, uint* Bmask, Span Amask) { // SpanOverloader @@ -2177,7 +2177,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, uint* Rmask, uint* Gmask, Span Bmask, uint* Amask) { // SpanOverloader @@ -2185,7 +2185,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, uint* Rmask, uint* Gmask, Span Bmask, Span Amask) { // SpanOverloader @@ -2193,7 +2193,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, uint* Rmask, Span Gmask, uint* Bmask, uint* Amask) { // SpanOverloader @@ -2201,7 +2201,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, uint* Rmask, Span Gmask, uint* Bmask, Span Amask) { // SpanOverloader @@ -2209,7 +2209,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, uint* Rmask, Span Gmask, Span Bmask, uint* Amask) { // SpanOverloader @@ -2217,7 +2217,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, uint* Rmask, Span Gmask, Span Bmask, Span Amask) { // SpanOverloader @@ -2225,7 +2225,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, Span Rmask, uint* Gmask, uint* Bmask, uint* Amask) { // SpanOverloader @@ -2233,7 +2233,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, Span Rmask, uint* Gmask, uint* Bmask, Span Amask) { // SpanOverloader @@ -2241,7 +2241,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, Span Rmask, uint* Gmask, Span Bmask, uint* Amask) { // SpanOverloader @@ -2249,7 +2249,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, Span Rmask, uint* Gmask, Span Bmask, Span Amask) { // SpanOverloader @@ -2257,7 +2257,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, Span Rmask, Span Gmask, uint* Bmask, uint* Amask) { // SpanOverloader @@ -2265,7 +2265,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, Span Rmask, Span Gmask, uint* Bmask, Span Amask) { // SpanOverloader @@ -2273,7 +2273,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, Span Rmask, Span Gmask, Span Bmask, uint* Amask) { // SpanOverloader @@ -2281,7 +2281,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, int* bpp, Span Rmask, Span Gmask, Span Bmask, Span Amask) { // SpanOverloader @@ -2289,7 +2289,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, uint* Rmask, uint* Gmask, uint* Bmask, uint* Amask) { // SpanOverloader @@ -2297,7 +2297,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, uint* Rmask, uint* Gmask, uint* Bmask, Span Amask) { // SpanOverloader @@ -2305,7 +2305,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, uint* Rmask, uint* Gmask, Span Bmask, uint* Amask) { // SpanOverloader @@ -2313,7 +2313,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, uint* Rmask, uint* Gmask, Span Bmask, Span Amask) { // SpanOverloader @@ -2321,7 +2321,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, uint* Rmask, Span Gmask, uint* Bmask, uint* Amask) { // SpanOverloader @@ -2329,7 +2329,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, uint* Rmask, Span Gmask, uint* Bmask, Span Amask) { // SpanOverloader @@ -2337,7 +2337,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, uint* Rmask, Span Gmask, Span Bmask, uint* Amask) { // SpanOverloader @@ -2345,7 +2345,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, uint* Rmask, Span Gmask, Span Bmask, Span Amask) { // SpanOverloader @@ -2353,7 +2353,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, Span Rmask, uint* Gmask, uint* Bmask, uint* Amask) { // SpanOverloader @@ -2361,7 +2361,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, Span Rmask, uint* Gmask, uint* Bmask, Span Amask) { // SpanOverloader @@ -2369,7 +2369,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, Span Rmask, uint* Gmask, Span Bmask, uint* Amask) { // SpanOverloader @@ -2377,7 +2377,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, Span Rmask, uint* Gmask, Span Bmask, Span Amask) { // SpanOverloader @@ -2385,7 +2385,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, Span Rmask, Span Gmask, uint* Bmask, uint* Amask) { // SpanOverloader @@ -2393,7 +2393,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, Span Rmask, Span Gmask, uint* Bmask, Span Amask) { // SpanOverloader @@ -2401,7 +2401,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, Span Rmask, Span Gmask, Span Bmask, uint* Amask) { // SpanOverloader @@ -2409,7 +2409,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 397, Column 34 in SDL_pixels.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_pixels.h")] public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint format, Span bpp, Span Rmask, Span Gmask, Span Bmask, Span Amask) { // SpanOverloader @@ -2417,7 +2417,7 @@ public static unsafe SdlBool PixelFormatEnumToMasks(this Sdl thisApi, uint forma } /// To be documented. - [NativeName("Src", "Line 453, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 477, Column 30 in SDL_pixels.h")] public static unsafe void FreeFormat(this Sdl thisApi, Span format) { // SpanOverloader @@ -2425,7 +2425,7 @@ public static unsafe void FreeFormat(this Sdl thisApi, Span format) } /// To be documented. - [NativeName("Src", "Line 484, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 508, Column 29 in SDL_pixels.h")] public static unsafe int SetPixelFormatPalette(this Sdl thisApi, PixelFormat* format, Span palette) { // SpanOverloader @@ -2433,7 +2433,7 @@ public static unsafe int SetPixelFormatPalette(this Sdl thisApi, PixelFormat* fo } /// To be documented. - [NativeName("Src", "Line 484, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 508, Column 29 in SDL_pixels.h")] public static unsafe int SetPixelFormatPalette(this Sdl thisApi, Span format, Palette* palette) { // SpanOverloader @@ -2441,7 +2441,7 @@ public static unsafe int SetPixelFormatPalette(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 484, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 508, Column 29 in SDL_pixels.h")] public static unsafe int SetPixelFormatPalette(this Sdl thisApi, Span format, Span palette) { // SpanOverloader @@ -2449,7 +2449,7 @@ public static unsafe int SetPixelFormatPalette(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 502, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_pixels.h")] public static unsafe int SetPaletteColors(this Sdl thisApi, Palette* palette, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan colors, int firstcolor, int ncolors) { // SpanOverloader @@ -2457,7 +2457,7 @@ public static unsafe int SetPaletteColors(this Sdl thisApi, Palette* palette, [F } /// To be documented. - [NativeName("Src", "Line 502, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_pixels.h")] public static unsafe int SetPaletteColors(this Sdl thisApi, Span palette, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* colors, int firstcolor, int ncolors) { // SpanOverloader @@ -2465,7 +2465,7 @@ public static unsafe int SetPaletteColors(this Sdl thisApi, Span palett } /// To be documented. - [NativeName("Src", "Line 502, Column 29 in SDL_pixels.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_pixels.h")] public static unsafe int SetPaletteColors(this Sdl thisApi, Span palette, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan colors, int firstcolor, int ncolors) { // SpanOverloader @@ -2473,7 +2473,7 @@ public static unsafe int SetPaletteColors(this Sdl thisApi, Span palett } /// To be documented. - [NativeName("Src", "Line 515, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 539, Column 30 in SDL_pixels.h")] public static unsafe void FreePalette(this Sdl thisApi, Span palette) { // SpanOverloader @@ -2481,7 +2481,7 @@ public static unsafe void FreePalette(this Sdl thisApi, Span palette) } /// To be documented. - [NativeName("Src", "Line 547, Column 32 in SDL_pixels.h")] + [NativeName("Src", "Line 571, Column 32 in SDL_pixels.h")] public static unsafe uint MapRGB(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte r, byte g, byte b) { // SpanOverloader @@ -2489,7 +2489,7 @@ public static unsafe uint MapRGB(this Sdl thisApi, [Flow(Silk.NET.Core.Native.Fl } /// To be documented. - [NativeName("Src", "Line 582, Column 32 in SDL_pixels.h")] + [NativeName("Src", "Line 606, Column 32 in SDL_pixels.h")] public static unsafe uint MapRGBA(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte r, byte g, byte b, byte a) { // SpanOverloader @@ -2497,7 +2497,7 @@ public static unsafe uint MapRGBA(this Sdl thisApi, [Flow(Silk.NET.Core.Native.F } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, Span b) { // SpanOverloader @@ -2505,7 +2505,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, byte* b) { // SpanOverloader @@ -2513,7 +2513,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, Span b) { // SpanOverloader @@ -2521,7 +2521,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2529,7 +2529,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -2537,7 +2537,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, byte* b) { // SpanOverloader @@ -2545,7 +2545,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, Span b) { // SpanOverloader @@ -2553,7 +2553,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2561,7 +2561,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, byte* b) { // SpanOverloader @@ -2569,7 +2569,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, Span b) { // SpanOverloader @@ -2577,7 +2577,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2585,7 +2585,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b) { // SpanOverloader @@ -2593,7 +2593,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -2601,7 +2601,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2609,7 +2609,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b) { // SpanOverloader @@ -2617,7 +2617,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b) { // SpanOverloader @@ -2625,7 +2625,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b) { // SpanOverloader @@ -2633,7 +2633,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2641,7 +2641,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -2649,7 +2649,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, byte* b) { // SpanOverloader @@ -2657,7 +2657,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, Span b) { // SpanOverloader @@ -2665,7 +2665,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2673,7 +2673,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, byte* b) { // SpanOverloader @@ -2681,7 +2681,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, Span b) { // SpanOverloader @@ -2689,7 +2689,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2697,7 +2697,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b) { // SpanOverloader @@ -2705,7 +2705,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -2713,7 +2713,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2721,7 +2721,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, byte* b) { // SpanOverloader @@ -2729,7 +2729,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, Span b) { // SpanOverloader @@ -2737,7 +2737,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2745,7 +2745,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, byte* b) { // SpanOverloader @@ -2753,7 +2753,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, Span b) { // SpanOverloader @@ -2761,7 +2761,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2769,7 +2769,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b) { // SpanOverloader @@ -2777,7 +2777,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -2785,7 +2785,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2793,7 +2793,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b) { // SpanOverloader @@ -2801,7 +2801,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b) { // SpanOverloader @@ -2809,7 +2809,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2817,7 +2817,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b) { // SpanOverloader @@ -2825,7 +2825,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b) { // SpanOverloader @@ -2833,7 +2833,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2841,7 +2841,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b) { // SpanOverloader @@ -2849,7 +2849,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -2857,7 +2857,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 607, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 631, Column 30 in SDL_pixels.h")] public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -2865,7 +2865,7 @@ public static unsafe void GetRGB(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, byte* b, Span a) { // SpanOverloader @@ -2873,7 +2873,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, Span b, byte* a) { // SpanOverloader @@ -2881,7 +2881,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, Span b, Span a) { // SpanOverloader @@ -2889,7 +2889,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -2897,7 +2897,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -2905,7 +2905,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, byte* b, byte* a) { // SpanOverloader @@ -2913,7 +2913,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, byte* b, Span a) { // SpanOverloader @@ -2921,7 +2921,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -2929,7 +2929,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, Span b, byte* a) { // SpanOverloader @@ -2937,7 +2937,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, Span b, Span a) { // SpanOverloader @@ -2945,7 +2945,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -2953,7 +2953,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -2961,7 +2961,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -2969,7 +2969,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -2977,7 +2977,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, Span a) { // SpanOverloader @@ -2985,7 +2985,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, byte* a) { // SpanOverloader @@ -2993,7 +2993,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, Span a) { // SpanOverloader @@ -3001,7 +3001,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3009,7 +3009,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3017,7 +3017,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, byte* b, byte* a) { // SpanOverloader @@ -3025,7 +3025,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, byte* b, Span a) { // SpanOverloader @@ -3033,7 +3033,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3041,7 +3041,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, Span b, byte* a) { // SpanOverloader @@ -3049,7 +3049,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, Span b, Span a) { // SpanOverloader @@ -3057,7 +3057,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3065,7 +3065,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3073,7 +3073,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3081,7 +3081,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3089,7 +3089,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, byte* b, byte* a) { // SpanOverloader @@ -3097,7 +3097,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, byte* b, Span a) { // SpanOverloader @@ -3105,7 +3105,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3113,7 +3113,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, Span b, byte* a) { // SpanOverloader @@ -3121,7 +3121,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, Span b, Span a) { // SpanOverloader @@ -3129,7 +3129,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3137,7 +3137,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3145,7 +3145,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3153,7 +3153,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3161,7 +3161,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a) { // SpanOverloader @@ -3169,7 +3169,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, Span a) { // SpanOverloader @@ -3177,7 +3177,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3185,7 +3185,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, byte* a) { // SpanOverloader @@ -3193,7 +3193,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, Span a) { // SpanOverloader @@ -3201,7 +3201,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3209,7 +3209,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3217,7 +3217,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3225,7 +3225,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3233,7 +3233,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, Span a) { // SpanOverloader @@ -3241,7 +3241,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b, byte* a) { // SpanOverloader @@ -3249,7 +3249,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b, Span a) { // SpanOverloader @@ -3257,7 +3257,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3265,7 +3265,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3273,7 +3273,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b, byte* a) { // SpanOverloader @@ -3281,7 +3281,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b, Span a) { // SpanOverloader @@ -3289,7 +3289,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3297,7 +3297,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b, byte* a) { // SpanOverloader @@ -3305,7 +3305,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b, Span a) { // SpanOverloader @@ -3313,7 +3313,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3321,7 +3321,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3329,7 +3329,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3337,7 +3337,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3345,7 +3345,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, Span a) { // SpanOverloader @@ -3353,7 +3353,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, byte* a) { // SpanOverloader @@ -3361,7 +3361,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, Span a) { // SpanOverloader @@ -3369,7 +3369,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3377,7 +3377,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3385,7 +3385,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, byte* b, byte* a) { // SpanOverloader @@ -3393,7 +3393,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, byte* b, Span a) { // SpanOverloader @@ -3401,7 +3401,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3409,7 +3409,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, Span b, byte* a) { // SpanOverloader @@ -3417,7 +3417,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, Span b, Span a) { // SpanOverloader @@ -3425,7 +3425,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3433,7 +3433,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3441,7 +3441,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3449,7 +3449,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3457,7 +3457,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, byte* b, byte* a) { // SpanOverloader @@ -3465,7 +3465,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, byte* b, Span a) { // SpanOverloader @@ -3473,7 +3473,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3481,7 +3481,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, Span b, byte* a) { // SpanOverloader @@ -3489,7 +3489,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, Span b, Span a) { // SpanOverloader @@ -3497,7 +3497,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3505,7 +3505,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3513,7 +3513,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3521,7 +3521,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3529,7 +3529,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a) { // SpanOverloader @@ -3537,7 +3537,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, Span a) { // SpanOverloader @@ -3545,7 +3545,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3553,7 +3553,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, byte* a) { // SpanOverloader @@ -3561,7 +3561,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, Span a) { // SpanOverloader @@ -3569,7 +3569,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3577,7 +3577,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3585,7 +3585,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3593,7 +3593,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3601,7 +3601,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, byte* b, byte* a) { // SpanOverloader @@ -3609,7 +3609,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, byte* b, Span a) { // SpanOverloader @@ -3617,7 +3617,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3625,7 +3625,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, Span b, byte* a) { // SpanOverloader @@ -3633,7 +3633,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, Span b, Span a) { // SpanOverloader @@ -3641,7 +3641,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3649,7 +3649,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3657,7 +3657,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3665,7 +3665,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3673,7 +3673,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, byte* b, byte* a) { // SpanOverloader @@ -3681,7 +3681,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, byte* b, Span a) { // SpanOverloader @@ -3689,7 +3689,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3697,7 +3697,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, Span b, byte* a) { // SpanOverloader @@ -3705,7 +3705,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, Span b, Span a) { // SpanOverloader @@ -3713,7 +3713,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3721,7 +3721,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3729,7 +3729,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3737,7 +3737,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3745,7 +3745,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a) { // SpanOverloader @@ -3753,7 +3753,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, Span a) { // SpanOverloader @@ -3761,7 +3761,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3769,7 +3769,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, byte* a) { // SpanOverloader @@ -3777,7 +3777,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, Span a) { // SpanOverloader @@ -3785,7 +3785,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3793,7 +3793,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3801,7 +3801,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3809,7 +3809,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3817,7 +3817,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, byte* a) { // SpanOverloader @@ -3825,7 +3825,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, Span a) { // SpanOverloader @@ -3833,7 +3833,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3841,7 +3841,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b, byte* a) { // SpanOverloader @@ -3849,7 +3849,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b, Span a) { // SpanOverloader @@ -3857,7 +3857,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3865,7 +3865,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3873,7 +3873,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3881,7 +3881,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3889,7 +3889,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b, byte* a) { // SpanOverloader @@ -3897,7 +3897,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b, Span a) { // SpanOverloader @@ -3905,7 +3905,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3913,7 +3913,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b, byte* a) { // SpanOverloader @@ -3921,7 +3921,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b, Span a) { // SpanOverloader @@ -3929,7 +3929,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3937,7 +3937,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -3945,7 +3945,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -3953,7 +3953,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3961,7 +3961,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a) { // SpanOverloader @@ -3969,7 +3969,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, Span a) { // SpanOverloader @@ -3977,7 +3977,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -3985,7 +3985,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, byte* a) { // SpanOverloader @@ -3993,7 +3993,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, Span a) { // SpanOverloader @@ -4001,7 +4001,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -4009,7 +4009,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -4017,7 +4017,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -4025,7 +4025,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 636, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 660, Column 30 in SDL_pixels.h")] public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan format, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -4033,7 +4033,7 @@ public static unsafe void GetRGBA(this Sdl thisApi, uint pixel, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 651, Column 30 in SDL_pixels.h")] + [NativeName("Src", "Line 675, Column 30 in SDL_pixels.h")] public static unsafe void CalculateGammaRamp(this Sdl thisApi, float gamma, Span ramp) { // SpanOverloader @@ -4937,7 +4937,7 @@ public static unsafe SdlBool IntersectFRectAndLine(this Sdl thisApi, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 219, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 220, Column 38 in SDL_surface.h")] public static unsafe Surface* CreateRGBSurfaceFrom(this Sdl thisApi, Span pixels, int width, int height, int depth, int pitch, uint Rmask, uint Gmask, uint Bmask, uint Amask) where T0 : unmanaged { // SpanOverloader @@ -4945,7 +4945,7 @@ public static unsafe SdlBool IntersectFRectAndLine(this Sdl thisApi, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 257, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 258, Column 38 in SDL_surface.h")] public static unsafe Surface* CreateRGBSurfaceWithFormatFrom(this Sdl thisApi, Span pixels, int width, int height, int depth, int pitch, uint format) where T0 : unmanaged { // SpanOverloader @@ -4953,7 +4953,7 @@ public static unsafe SdlBool IntersectFRectAndLine(this Sdl thisApi, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 274, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 275, Column 30 in SDL_surface.h")] public static unsafe void FreeSurface(this Sdl thisApi, Span surface) { // SpanOverloader @@ -4961,7 +4961,7 @@ public static unsafe void FreeSurface(this Sdl thisApi, Span surface) } /// To be documented. - [NativeName("Src", "Line 288, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 289, Column 29 in SDL_surface.h")] public static unsafe int SetSurfacePalette(this Sdl thisApi, Surface* surface, Span palette) { // SpanOverloader @@ -4969,7 +4969,7 @@ public static unsafe int SetSurfacePalette(this Sdl thisApi, Surface* surface, S } /// To be documented. - [NativeName("Src", "Line 288, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 289, Column 29 in SDL_surface.h")] public static unsafe int SetSurfacePalette(this Sdl thisApi, Span surface, Palette* palette) { // SpanOverloader @@ -4977,7 +4977,7 @@ public static unsafe int SetSurfacePalette(this Sdl thisApi, Span surfa } /// To be documented. - [NativeName("Src", "Line 288, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 289, Column 29 in SDL_surface.h")] public static unsafe int SetSurfacePalette(this Sdl thisApi, Span surface, Span palette) { // SpanOverloader @@ -4985,7 +4985,7 @@ public static unsafe int SetSurfacePalette(this Sdl thisApi, Span surfa } /// To be documented. - [NativeName("Src", "Line 312, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 313, Column 29 in SDL_surface.h")] public static unsafe int LockSurface(this Sdl thisApi, Span surface) { // SpanOverloader @@ -4993,7 +4993,7 @@ public static unsafe int LockSurface(this Sdl thisApi, Span surface) } /// To be documented. - [NativeName("Src", "Line 323, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 324, Column 30 in SDL_surface.h")] public static unsafe void UnlockSurface(this Sdl thisApi, Span surface) { // SpanOverloader @@ -5001,7 +5001,7 @@ public static unsafe void UnlockSurface(this Sdl thisApi, Span surface) } /// To be documented. - [NativeName("Src", "Line 347, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 348, Column 38 in SDL_surface.h")] public static unsafe Surface* LoadBMPRW(this Sdl thisApi, Span src, int freesrc) { // SpanOverloader @@ -5009,7 +5009,7 @@ public static unsafe void UnlockSurface(this Sdl thisApi, Span surface) } /// To be documented. - [NativeName("Src", "Line 377, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 378, Column 29 in SDL_surface.h")] public static unsafe int SaveBMPRW(this Sdl thisApi, Surface* surface, Span dst, int freedst) { // SpanOverloader @@ -5017,7 +5017,7 @@ public static unsafe int SaveBMPRW(this Sdl thisApi, Surface* surface, SpanTo be documented. - [NativeName("Src", "Line 377, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 378, Column 29 in SDL_surface.h")] public static unsafe int SaveBMPRW(this Sdl thisApi, Span surface, RWops* dst, int freedst) { // SpanOverloader @@ -5025,7 +5025,7 @@ public static unsafe int SaveBMPRW(this Sdl thisApi, Span surface, RWop } /// To be documented. - [NativeName("Src", "Line 377, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 378, Column 29 in SDL_surface.h")] public static unsafe int SaveBMPRW(this Sdl thisApi, Span surface, Span dst, int freedst) { // SpanOverloader @@ -5033,7 +5033,7 @@ public static unsafe int SaveBMPRW(this Sdl thisApi, Span surface, Span } /// To be documented. - [NativeName("Src", "Line 405, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 406, Column 29 in SDL_surface.h")] public static unsafe int SetSurfaceRLE(this Sdl thisApi, Span surface, int flag) { // SpanOverloader @@ -5041,7 +5041,7 @@ public static unsafe int SetSurfaceRLE(this Sdl thisApi, Span surface, } /// To be documented. - [NativeName("Src", "Line 420, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 421, Column 34 in SDL_surface.h")] public static unsafe SdlBool HasSurfaceRLE(this Sdl thisApi, Span surface) { // SpanOverloader @@ -5049,7 +5049,7 @@ public static unsafe SdlBool HasSurfaceRLE(this Sdl thisApi, Span surfa } /// To be documented. - [NativeName("Src", "Line 446, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 447, Column 29 in SDL_surface.h")] public static unsafe int SetColorKey(this Sdl thisApi, Span surface, int flag, uint key) { // SpanOverloader @@ -5057,7 +5057,7 @@ public static unsafe int SetColorKey(this Sdl thisApi, Span surface, in } /// To be documented. - [NativeName("Src", "Line 462, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 463, Column 34 in SDL_surface.h")] public static unsafe SdlBool HasColorKey(this Sdl thisApi, Span surface) { // SpanOverloader @@ -5065,7 +5065,7 @@ public static unsafe SdlBool HasColorKey(this Sdl thisApi, Span surface } /// To be documented. - [NativeName("Src", "Line 482, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 483, Column 29 in SDL_surface.h")] public static unsafe int GetColorKey(this Sdl thisApi, Surface* surface, Span key) { // SpanOverloader @@ -5073,7 +5073,7 @@ public static unsafe int GetColorKey(this Sdl thisApi, Surface* surface, SpanTo be documented. - [NativeName("Src", "Line 482, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 483, Column 29 in SDL_surface.h")] public static unsafe int GetColorKey(this Sdl thisApi, Span surface, uint* key) { // SpanOverloader @@ -5081,7 +5081,7 @@ public static unsafe int GetColorKey(this Sdl thisApi, Span surface, ui } /// To be documented. - [NativeName("Src", "Line 482, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 483, Column 29 in SDL_surface.h")] public static unsafe int GetColorKey(this Sdl thisApi, Span surface, Span key) { // SpanOverloader @@ -5089,7 +5089,7 @@ public static unsafe int GetColorKey(this Sdl thisApi, Span surface, Sp } /// To be documented. - [NativeName("Src", "Line 506, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 507, Column 29 in SDL_surface.h")] public static unsafe int SetSurfaceColorMod(this Sdl thisApi, Span surface, byte r, byte g, byte b) { // SpanOverloader @@ -5097,7 +5097,7 @@ public static unsafe int SetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, byte* r, byte* g, Span b) { // SpanOverloader @@ -5105,7 +5105,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, byte* r, Span g, byte* b) { // SpanOverloader @@ -5113,7 +5113,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, byte* r, Span g, Span b) { // SpanOverloader @@ -5121,7 +5121,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5129,7 +5129,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -5137,7 +5137,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, Span r, byte* g, byte* b) { // SpanOverloader @@ -5145,7 +5145,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, Span r, byte* g, Span b) { // SpanOverloader @@ -5153,7 +5153,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5161,7 +5161,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, Span r, Span g, byte* b) { // SpanOverloader @@ -5169,7 +5169,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, Span r, Span g, Span b) { // SpanOverloader @@ -5177,7 +5177,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5185,7 +5185,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b) { // SpanOverloader @@ -5193,7 +5193,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -5201,7 +5201,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5209,7 +5209,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b) { // SpanOverloader @@ -5217,7 +5217,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b) { // SpanOverloader @@ -5225,7 +5225,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b) { // SpanOverloader @@ -5233,7 +5233,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5241,7 +5241,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -5249,7 +5249,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, byte* r, byte* g, byte* b) { // SpanOverloader @@ -5257,7 +5257,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, byte* r, byte* g, Span b) { // SpanOverloader @@ -5265,7 +5265,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5273,7 +5273,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, byte* r, Span g, byte* b) { // SpanOverloader @@ -5281,7 +5281,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, byte* r, Span g, Span b) { // SpanOverloader @@ -5289,7 +5289,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5297,7 +5297,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b) { // SpanOverloader @@ -5305,7 +5305,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -5313,7 +5313,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5321,7 +5321,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, Span r, byte* g, byte* b) { // SpanOverloader @@ -5329,7 +5329,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, Span r, byte* g, Span b) { // SpanOverloader @@ -5337,7 +5337,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5345,7 +5345,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, Span r, Span g, byte* b) { // SpanOverloader @@ -5353,7 +5353,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, Span r, Span g, Span b) { // SpanOverloader @@ -5361,7 +5361,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5369,7 +5369,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b) { // SpanOverloader @@ -5377,7 +5377,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -5385,7 +5385,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5393,7 +5393,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b) { // SpanOverloader @@ -5401,7 +5401,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b) { // SpanOverloader @@ -5409,7 +5409,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5417,7 +5417,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b) { // SpanOverloader @@ -5425,7 +5425,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b) { // SpanOverloader @@ -5433,7 +5433,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5441,7 +5441,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b) { // SpanOverloader @@ -5449,7 +5449,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -5457,7 +5457,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 525, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 526, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -5465,7 +5465,7 @@ public static unsafe int GetSurfaceColorMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 547, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 548, Column 29 in SDL_surface.h")] public static unsafe int SetSurfaceAlphaMod(this Sdl thisApi, Span surface, byte alpha) { // SpanOverloader @@ -5473,7 +5473,7 @@ public static unsafe int SetSurfaceAlphaMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 563, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 564, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceAlphaMod(this Sdl thisApi, Surface* surface, Span alpha) { // SpanOverloader @@ -5481,7 +5481,7 @@ public static unsafe int GetSurfaceAlphaMod(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 563, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 564, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceAlphaMod(this Sdl thisApi, Span surface, byte* alpha) { // SpanOverloader @@ -5489,7 +5489,7 @@ public static unsafe int GetSurfaceAlphaMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 563, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 564, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceAlphaMod(this Sdl thisApi, Span surface, Span alpha) { // SpanOverloader @@ -5497,7 +5497,7 @@ public static unsafe int GetSurfaceAlphaMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 563, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 564, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceAlphaMod(this Sdl thisApi, Span surface, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string alpha) { // SpanOverloader @@ -5505,7 +5505,7 @@ public static unsafe int GetSurfaceAlphaMod(this Sdl thisApi, Span surf } /// To be documented. - [NativeName("Src", "Line 582, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 583, Column 29 in SDL_surface.h")] public static unsafe int SetSurfaceBlendMode(this Sdl thisApi, Span surface, BlendMode blendMode) { // SpanOverloader @@ -5513,7 +5513,7 @@ public static unsafe int SetSurfaceBlendMode(this Sdl thisApi, Span sur } /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceBlendMode(this Sdl thisApi, Surface* surface, Span blendMode) { // SpanOverloader @@ -5521,7 +5521,7 @@ public static unsafe int GetSurfaceBlendMode(this Sdl thisApi, Surface* surface, } /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceBlendMode(this Sdl thisApi, Span surface, BlendMode* blendMode) { // SpanOverloader @@ -5529,7 +5529,7 @@ public static unsafe int GetSurfaceBlendMode(this Sdl thisApi, Span sur } /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_surface.h")] public static unsafe int GetSurfaceBlendMode(this Sdl thisApi, Span surface, Span blendMode) { // SpanOverloader @@ -5537,7 +5537,7 @@ public static unsafe int GetSurfaceBlendMode(this Sdl thisApi, Span sur } /// To be documented. - [NativeName("Src", "Line 620, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 621, Column 34 in SDL_surface.h")] public static unsafe SdlBool SetClipRect(this Sdl thisApi, Surface* surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect) { // SpanOverloader @@ -5545,7 +5545,7 @@ public static unsafe SdlBool SetClipRect(this Sdl thisApi, Surface* surface, [Fl } /// To be documented. - [NativeName("Src", "Line 620, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 621, Column 34 in SDL_surface.h")] public static unsafe SdlBool SetClipRect(this Sdl thisApi, Span surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect) { // SpanOverloader @@ -5553,7 +5553,7 @@ public static unsafe SdlBool SetClipRect(this Sdl thisApi, Span surface } /// To be documented. - [NativeName("Src", "Line 620, Column 34 in SDL_surface.h")] + [NativeName("Src", "Line 621, Column 34 in SDL_surface.h")] public static unsafe SdlBool SetClipRect(this Sdl thisApi, Span surface, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect) { // SpanOverloader @@ -5561,7 +5561,7 @@ public static unsafe SdlBool SetClipRect(this Sdl thisApi, Span surface } /// To be documented. - [NativeName("Src", "Line 639, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 640, Column 30 in SDL_surface.h")] public static unsafe void GetClipRect(this Sdl thisApi, Surface* surface, Span> rect) { // SpanOverloader @@ -5569,7 +5569,7 @@ public static unsafe void GetClipRect(this Sdl thisApi, Surface* surface, SpanTo be documented. - [NativeName("Src", "Line 639, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 640, Column 30 in SDL_surface.h")] public static unsafe void GetClipRect(this Sdl thisApi, Span surface, Silk.NET.Maths.Rectangle* rect) { // SpanOverloader @@ -5577,7 +5577,7 @@ public static unsafe void GetClipRect(this Sdl thisApi, Span surface, S } /// To be documented. - [NativeName("Src", "Line 639, Column 30 in SDL_surface.h")] + [NativeName("Src", "Line 640, Column 30 in SDL_surface.h")] public static unsafe void GetClipRect(this Sdl thisApi, Span surface, Span> rect) { // SpanOverloader @@ -5585,7 +5585,7 @@ public static unsafe void GetClipRect(this Sdl thisApi, Span surface, S } /// To be documented. - [NativeName("Src", "Line 651, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 652, Column 38 in SDL_surface.h")] public static unsafe Surface* DuplicateSurface(this Sdl thisApi, Span surface) { // SpanOverloader @@ -5593,7 +5593,7 @@ public static unsafe void GetClipRect(this Sdl thisApi, Span surface, S } /// To be documented. - [NativeName("Src", "Line 675, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 676, Column 38 in SDL_surface.h")] public static unsafe Surface* ConvertSurface(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, uint flags) { // SpanOverloader @@ -5601,7 +5601,7 @@ public static unsafe void GetClipRect(this Sdl thisApi, Span surface, S } /// To be documented. - [NativeName("Src", "Line 675, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 676, Column 38 in SDL_surface.h")] public static unsafe Surface* ConvertSurface(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PixelFormat* fmt, uint flags) { // SpanOverloader @@ -5609,7 +5609,7 @@ public static unsafe void GetClipRect(this Sdl thisApi, Span surface, S } /// To be documented. - [NativeName("Src", "Line 675, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 676, Column 38 in SDL_surface.h")] public static unsafe Surface* ConvertSurface(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan fmt, uint flags) { // SpanOverloader @@ -5617,7 +5617,7 @@ public static unsafe void GetClipRect(this Sdl thisApi, Span surface, S } /// To be documented. - [NativeName("Src", "Line 700, Column 38 in SDL_surface.h")] + [NativeName("Src", "Line 701, Column 38 in SDL_surface.h")] public static unsafe Surface* ConvertSurfaceFormat(this Sdl thisApi, Span src, uint pixel_format, uint flags) { // SpanOverloader @@ -5625,7 +5625,7 @@ public static unsafe void GetClipRect(this Sdl thisApi, Span surface, S } /// To be documented. - [NativeName("Src", "Line 719, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 720, Column 29 in SDL_surface.h")] public static unsafe int ConvertPixels(this Sdl thisApi, int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, int src_pitch, uint dst_format, Span dst, int dst_pitch) where T0 : unmanaged { // SpanOverloader @@ -5633,7 +5633,7 @@ public static unsafe int ConvertPixels(this Sdl thisApi, int width, int heig } /// To be documented. - [NativeName("Src", "Line 719, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 720, Column 29 in SDL_surface.h")] public static unsafe int ConvertPixels(this Sdl thisApi, int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, int src_pitch, uint dst_format, void* dst, int dst_pitch) where T0 : unmanaged { // SpanOverloader @@ -5641,7 +5641,7 @@ public static unsafe int ConvertPixels(this Sdl thisApi, int width, int heig } /// To be documented. - [NativeName("Src", "Line 719, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 720, Column 29 in SDL_surface.h")] public static unsafe int ConvertPixels(this Sdl thisApi, int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, int src_pitch, uint dst_format, Span dst, int dst_pitch) where T0 : unmanaged where T1 : unmanaged { // SpanOverloader @@ -5649,7 +5649,7 @@ public static unsafe int ConvertPixels(this Sdl thisApi, int width, int } /// To be documented. - [NativeName("Src", "Line 745, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 746, Column 29 in SDL_surface.h")] public static unsafe int PremultiplyAlpha(this Sdl thisApi, int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* src, int src_pitch, uint dst_format, Span dst, int dst_pitch) where T0 : unmanaged { // SpanOverloader @@ -5657,7 +5657,7 @@ public static unsafe int PremultiplyAlpha(this Sdl thisApi, int width, int h } /// To be documented. - [NativeName("Src", "Line 745, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 746, Column 29 in SDL_surface.h")] public static unsafe int PremultiplyAlpha(this Sdl thisApi, int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, int src_pitch, uint dst_format, void* dst, int dst_pitch) where T0 : unmanaged { // SpanOverloader @@ -5665,7 +5665,7 @@ public static unsafe int PremultiplyAlpha(this Sdl thisApi, int width, int h } /// To be documented. - [NativeName("Src", "Line 745, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 746, Column 29 in SDL_surface.h")] public static unsafe int PremultiplyAlpha(this Sdl thisApi, int width, int height, uint src_format, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, int src_pitch, uint dst_format, Span dst, int dst_pitch) where T0 : unmanaged where T1 : unmanaged { // SpanOverloader @@ -5673,7 +5673,7 @@ public static unsafe int PremultiplyAlpha(this Sdl thisApi, int width, i } /// To be documented. - [NativeName("Src", "Line 774, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 775, Column 29 in SDL_surface.h")] public static unsafe int FillRect(this Sdl thisApi, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, uint color) { // SpanOverloader @@ -5681,7 +5681,7 @@ public static unsafe int FillRect(this Sdl thisApi, Surface* dst, [Flow(Silk.NET } /// To be documented. - [NativeName("Src", "Line 774, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 775, Column 29 in SDL_surface.h")] public static unsafe int FillRect(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, uint color) { // SpanOverloader @@ -5689,7 +5689,7 @@ public static unsafe int FillRect(this Sdl thisApi, Span dst, [Flow(Sil } /// To be documented. - [NativeName("Src", "Line 774, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 775, Column 29 in SDL_surface.h")] public static unsafe int FillRect(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, uint color) { // SpanOverloader @@ -5697,7 +5697,7 @@ public static unsafe int FillRect(this Sdl thisApi, Span dst, [Flow(Sil } /// To be documented. - [NativeName("Src", "Line 800, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 801, Column 29 in SDL_surface.h")] public static unsafe int FillRects(this Sdl thisApi, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rects, int count, uint color) { // SpanOverloader @@ -5705,7 +5705,7 @@ public static unsafe int FillRects(this Sdl thisApi, Surface* dst, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 800, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 801, Column 29 in SDL_surface.h")] public static unsafe int FillRects(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rects, int count, uint color) { // SpanOverloader @@ -5713,7 +5713,7 @@ public static unsafe int FillRects(this Sdl thisApi, Span dst, [Flow(Si } /// To be documented. - [NativeName("Src", "Line 800, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 801, Column 29 in SDL_surface.h")] public static unsafe int FillRects(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rects, int count, uint color) { // SpanOverloader @@ -5721,7 +5721,7 @@ public static unsafe int FillRects(this Sdl thisApi, Span dst, [Flow(Si } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -5729,7 +5729,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5737,7 +5737,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -5745,7 +5745,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5753,7 +5753,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -5761,7 +5761,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5769,7 +5769,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -5777,7 +5777,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Surface* src, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5785,7 +5785,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Si } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -5793,7 +5793,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Si } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5801,7 +5801,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Si } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -5809,7 +5809,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Si } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5817,7 +5817,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Si } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -5825,7 +5825,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Si } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5833,7 +5833,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Si } /// To be documented. - [NativeName("Src", "Line 873, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 876, Column 29 in SDL_surface.h")] public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -5841,7 +5841,7 @@ public static unsafe int UpperBlit(this Sdl thisApi, Span src, [Flow(Si } /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -5849,7 +5849,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, Silk.NET.Math } /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, Silk.NET.Maths.Rectangle* srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5857,7 +5857,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, Silk.NET.Math } /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, Silk.NET.Maths.Rectangle* srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -5865,7 +5865,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, Silk.NET.Math } /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, Span> srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5873,7 +5873,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, SpanTo be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, Span> srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -5881,7 +5881,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, SpanTo be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, Span> srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5889,7 +5889,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, SpanTo be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, Span> srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -5897,7 +5897,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Surface* src, SpanTo be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Span src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5905,7 +5905,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Span src, Silk.NET } /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Span src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -5913,7 +5913,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Span src, Silk.NET } /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Span src, Silk.NET.Maths.Rectangle* srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5921,7 +5921,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Span src, Silk.NET } /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Span src, Silk.NET.Maths.Rectangle* srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -5929,7 +5929,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Span src, Silk.NET } /// To be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Span src, Span> srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5937,7 +5937,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Span src, SpanTo be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Span src, Span> srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -5945,7 +5945,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Span src, SpanTo be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Span src, Span> srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5953,7 +5953,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Span src, SpanTo be documented. - [NativeName("Src", "Line 899, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 902, Column 29 in SDL_surface.h")] public static unsafe int LowerBlit(this Sdl thisApi, Span src, Span> srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -5961,7 +5961,7 @@ public static unsafe int LowerBlit(this Sdl thisApi, Span src, SpanTo be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -5969,7 +5969,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5977,7 +5977,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -5985,7 +5985,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -5993,7 +5993,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6001,7 +6001,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6009,7 +6009,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6017,7 +6017,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Surface* src, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6025,7 +6025,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow( } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6033,7 +6033,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow( } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6041,7 +6041,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow( } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6049,7 +6049,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow( } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6057,7 +6057,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow( } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6065,7 +6065,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow( } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6073,7 +6073,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow( } /// To be documented. - [NativeName("Src", "Line 912, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 915, Column 29 in SDL_surface.h")] public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6081,7 +6081,7 @@ public static unsafe int SoftStretch(this Sdl thisApi, Span src, [Flow( } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6089,7 +6089,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6097,7 +6097,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6105,7 +6105,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6113,7 +6113,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6121,7 +6121,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6129,7 +6129,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6137,7 +6137,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Surface* src, [Flow } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6145,7 +6145,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6153,7 +6153,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6161,7 +6161,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6169,7 +6169,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6177,7 +6177,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6185,7 +6185,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6193,7 +6193,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, } /// To be documented. - [NativeName("Src", "Line 922, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 925, Column 29 in SDL_surface.h")] public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -6201,7 +6201,7 @@ public static unsafe int SoftStretchLinear(this Sdl thisApi, Span src, } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -6209,7 +6209,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(S } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6217,7 +6217,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(S } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -6225,7 +6225,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(S } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6233,7 +6233,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(S } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -6241,7 +6241,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(S } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6249,7 +6249,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(S } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -6257,7 +6257,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Surface* src, [Flow(S } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6265,7 +6265,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [F } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -6273,7 +6273,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [F } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6281,7 +6281,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [F } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -6289,7 +6289,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [F } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6297,7 +6297,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [F } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -6305,7 +6305,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [F } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6313,7 +6313,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [F } /// To be documented. - [NativeName("Src", "Line 940, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 941, Column 29 in SDL_surface.h")] public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -6321,7 +6321,7 @@ public static unsafe int UpperBlitScaled(this Sdl thisApi, Span src, [F } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -6329,7 +6329,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, Silk.NE } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, Silk.NET.Maths.Rectangle* srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6337,7 +6337,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, Silk.NE } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, Silk.NET.Maths.Rectangle* srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -6345,7 +6345,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, Silk.NE } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, Span> srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6353,7 +6353,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, SpanTo be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, Span> srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -6361,7 +6361,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, SpanTo be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, Span> srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6369,7 +6369,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, SpanTo be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, Span> srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -6377,7 +6377,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Surface* src, SpanTo be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6385,7 +6385,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Si } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Silk.NET.Maths.Rectangle* srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -6393,7 +6393,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Si } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Silk.NET.Maths.Rectangle* srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6401,7 +6401,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Si } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Silk.NET.Maths.Rectangle* srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -6409,7 +6409,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Si } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Span> srcrect, Surface* dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6417,7 +6417,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Sp } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Span> srcrect, Surface* dst, Span> dstrect) { // SpanOverloader @@ -6425,7 +6425,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Sp } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Span> srcrect, Span dst, Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -6433,7 +6433,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Sp } /// To be documented. - [NativeName("Src", "Line 963, Column 29 in SDL_surface.h")] + [NativeName("Src", "Line 967, Column 29 in SDL_surface.h")] public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Span> srcrect, Span dst, Span> dstrect) { // SpanOverloader @@ -6441,7 +6441,7 @@ public static unsafe int LowerBlitScaled(this Sdl thisApi, Span src, Sp } /// To be documented. - [NativeName("Src", "Line 341, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 373, Column 29 in SDL_video.h")] public static unsafe int VideoInit(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan driver_name) { // SpanOverloader @@ -6449,7 +6449,7 @@ public static unsafe int VideoInit(this Sdl thisApi, [Flow(Silk.NET.Core.Native. } /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 439, Column 29 in SDL_video.h")] public static unsafe int GetDisplayBounds(this Sdl thisApi, int displayIndex, Span> rect) { // SpanOverloader @@ -6457,7 +6457,7 @@ public static unsafe int GetDisplayBounds(this Sdl thisApi, int displayIndex, Sp } /// To be documented. - [NativeName("Src", "Line 438, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 470, Column 29 in SDL_video.h")] public static unsafe int GetDisplayUsableBounds(this Sdl thisApi, int displayIndex, Span> rect) { // SpanOverloader @@ -6465,7 +6465,7 @@ public static unsafe int GetDisplayUsableBounds(this Sdl thisApi, int displayInd } /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, float* ddpi, float* hdpi, Span vdpi) { // SpanOverloader @@ -6473,7 +6473,7 @@ public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, float } /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, float* ddpi, Span hdpi, float* vdpi) { // SpanOverloader @@ -6481,7 +6481,7 @@ public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, float } /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, float* ddpi, Span hdpi, Span vdpi) { // SpanOverloader @@ -6489,7 +6489,7 @@ public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, float } /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, Span ddpi, float* hdpi, float* vdpi) { // SpanOverloader @@ -6497,7 +6497,7 @@ public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, Span< } /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, Span ddpi, float* hdpi, Span vdpi) { // SpanOverloader @@ -6505,7 +6505,7 @@ public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, Span< } /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, Span ddpi, Span hdpi, float* vdpi) { // SpanOverloader @@ -6513,7 +6513,7 @@ public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, Span< } /// To be documented. - [NativeName("Src", "Line 473, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 505, Column 29 in SDL_video.h")] public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, Span ddpi, Span hdpi, Span vdpi) { // SpanOverloader @@ -6521,7 +6521,7 @@ public static unsafe int GetDisplayDPI(this Sdl thisApi, int displayIndex, Span< } /// To be documented. - [NativeName("Src", "Line 527, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 559, Column 29 in SDL_video.h")] public static unsafe int GetDisplayMode(this Sdl thisApi, int displayIndex, int modeIndex, Span mode) { // SpanOverloader @@ -6529,7 +6529,7 @@ public static unsafe int GetDisplayMode(this Sdl thisApi, int displayIndex, int } /// To be documented. - [NativeName("Src", "Line 550, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 582, Column 29 in SDL_video.h")] public static unsafe int GetDesktopDisplayMode(this Sdl thisApi, int displayIndex, Span mode) { // SpanOverloader @@ -6537,7 +6537,7 @@ public static unsafe int GetDesktopDisplayMode(this Sdl thisApi, int displayInde } /// To be documented. - [NativeName("Src", "Line 573, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 605, Column 29 in SDL_video.h")] public static unsafe int GetCurrentDisplayMode(this Sdl thisApi, int displayIndex, Span mode) { // SpanOverloader @@ -6545,7 +6545,7 @@ public static unsafe int GetCurrentDisplayMode(this Sdl thisApi, int displayInde } /// To be documented. - [NativeName("Src", "Line 599, Column 43 in SDL_video.h")] + [NativeName("Src", "Line 631, Column 43 in SDL_video.h")] public static unsafe DisplayMode* GetClosestDisplayMode(this Sdl thisApi, int displayIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] DisplayMode* mode, Span closest) { // SpanOverloader @@ -6553,7 +6553,7 @@ public static unsafe int GetCurrentDisplayMode(this Sdl thisApi, int displayInde } /// To be documented. - [NativeName("Src", "Line 599, Column 43 in SDL_video.h")] + [NativeName("Src", "Line 631, Column 43 in SDL_video.h")] public static unsafe DisplayMode* GetClosestDisplayMode(this Sdl thisApi, int displayIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan mode, DisplayMode* closest) { // SpanOverloader @@ -6561,7 +6561,7 @@ public static unsafe int GetCurrentDisplayMode(this Sdl thisApi, int displayInde } /// To be documented. - [NativeName("Src", "Line 599, Column 43 in SDL_video.h")] + [NativeName("Src", "Line 631, Column 43 in SDL_video.h")] public static unsafe DisplayMode* GetClosestDisplayMode(this Sdl thisApi, int displayIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan mode, Span closest) { // SpanOverloader @@ -6569,7 +6569,7 @@ public static unsafe int GetCurrentDisplayMode(this Sdl thisApi, int displayInde } /// To be documented. - [NativeName("Src", "Line 613, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 645, Column 29 in SDL_video.h")] public static unsafe int GetPointDisplayIndex(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan point) { // SpanOverloader @@ -6577,7 +6577,7 @@ public static unsafe int GetPointDisplayIndex(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 660, Column 29 in SDL_video.h")] public static unsafe int GetRectDisplayIndex(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect) { // SpanOverloader @@ -6585,7 +6585,7 @@ public static unsafe int GetRectDisplayIndex(this Sdl thisApi, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 664, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 696, Column 29 in SDL_video.h")] public static unsafe int SetWindowDisplayMode(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan mode) { // SpanOverloader @@ -6593,7 +6593,7 @@ public static unsafe int SetWindowDisplayMode(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 681, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 713, Column 29 in SDL_video.h")] public static unsafe int GetWindowDisplayMode(this Sdl thisApi, Window* window, Span mode) { // SpanOverloader @@ -6601,7 +6601,7 @@ public static unsafe int GetWindowDisplayMode(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 696, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 728, Column 31 in SDL_video.h")] public static unsafe void* GetWindowICCProfile(this Sdl thisApi, Window* window, Span size) { // SpanOverloader @@ -6609,7 +6609,7 @@ public static unsafe int GetWindowDisplayMode(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 781, Column 38 in SDL_video.h")] + [NativeName("Src", "Line 813, Column 38 in SDL_video.h")] public static unsafe Window* CreateWindow(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan title, int x, int y, int w, int h, uint flags) { // SpanOverloader @@ -6617,7 +6617,7 @@ public static unsafe int GetWindowDisplayMode(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 802, Column 38 in SDL_video.h")] + [NativeName("Src", "Line 834, Column 38 in SDL_video.h")] public static unsafe Window* CreateWindowFrom(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data) where T0 : unmanaged { // SpanOverloader @@ -6625,7 +6625,7 @@ public static unsafe int GetWindowDisplayMode(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 866, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 898, Column 30 in SDL_video.h")] public static unsafe void SetWindowTitle(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan title) { // SpanOverloader @@ -6633,7 +6633,7 @@ public static unsafe void SetWindowTitle(this Sdl thisApi, Window* window, [Flow } /// To be documented. - [NativeName("Src", "Line 890, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 922, Column 30 in SDL_video.h")] public static unsafe void SetWindowIcon(this Sdl thisApi, Window* window, Span icon) { // SpanOverloader @@ -6641,7 +6641,7 @@ public static unsafe void SetWindowIcon(this Sdl thisApi, Window* window, SpanTo be documented. - [NativeName("Src", "Line 907, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 939, Column 31 in SDL_video.h")] public static unsafe void* SetWindowData(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -6649,7 +6649,7 @@ public static unsafe void SetWindowIcon(this Sdl thisApi, Window* window, SpanTo be documented. - [NativeName("Src", "Line 907, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 939, Column 31 in SDL_video.h")] public static unsafe void* SetWindowData(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, void* userdata) { // SpanOverloader @@ -6657,7 +6657,7 @@ public static unsafe void SetWindowIcon(this Sdl thisApi, Window* window, SpanTo be documented. - [NativeName("Src", "Line 907, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 939, Column 31 in SDL_video.h")] public static unsafe void* SetWindowData(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -6665,7 +6665,7 @@ public static unsafe void SetWindowIcon(this Sdl thisApi, Window* window, SpanTo be documented. - [NativeName("Src", "Line 907, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 939, Column 31 in SDL_video.h")] public static unsafe void* SetWindowData(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -6673,7 +6673,7 @@ public static unsafe void SetWindowIcon(this Sdl thisApi, Window* window, SpanTo be documented. - [NativeName("Src", "Line 922, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 954, Column 31 in SDL_video.h")] public static unsafe void* GetWindowData(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name) { // SpanOverloader @@ -6681,7 +6681,7 @@ public static unsafe void SetWindowIcon(this Sdl thisApi, Window* window, SpanTo be documented. - [NativeName("Src", "Line 959, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 991, Column 30 in SDL_video.h")] public static unsafe void GetWindowPosition(this Sdl thisApi, Window* window, int* x, Span y) { // SpanOverloader @@ -6689,7 +6689,7 @@ public static unsafe void GetWindowPosition(this Sdl thisApi, Window* window, in } /// To be documented. - [NativeName("Src", "Line 959, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 991, Column 30 in SDL_video.h")] public static unsafe void GetWindowPosition(this Sdl thisApi, Window* window, Span x, int* y) { // SpanOverloader @@ -6697,7 +6697,7 @@ public static unsafe void GetWindowPosition(this Sdl thisApi, Window* window, Sp } /// To be documented. - [NativeName("Src", "Line 959, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 991, Column 30 in SDL_video.h")] public static unsafe void GetWindowPosition(this Sdl thisApi, Window* window, Span x, Span y) { // SpanOverloader @@ -6705,7 +6705,7 @@ public static unsafe void GetWindowPosition(this Sdl thisApi, Window* window, Sp } /// To be documented. - [NativeName("Src", "Line 1011, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1043, Column 30 in SDL_video.h")] public static unsafe void GetWindowSize(this Sdl thisApi, Window* window, int* w, Span h) { // SpanOverloader @@ -6713,7 +6713,7 @@ public static unsafe void GetWindowSize(this Sdl thisApi, Window* window, int* w } /// To be documented. - [NativeName("Src", "Line 1011, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1043, Column 30 in SDL_video.h")] public static unsafe void GetWindowSize(this Sdl thisApi, Window* window, Span w, int* h) { // SpanOverloader @@ -6721,7 +6721,7 @@ public static unsafe void GetWindowSize(this Sdl thisApi, Window* window, SpanTo be documented. - [NativeName("Src", "Line 1011, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1043, Column 30 in SDL_video.h")] public static unsafe void GetWindowSize(this Sdl thisApi, Window* window, Span w, Span h) { // SpanOverloader @@ -6729,7 +6729,7 @@ public static unsafe void GetWindowSize(this Sdl thisApi, Window* window, SpanTo be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, int* top, int* left, int* bottom, Span right) { // SpanOverloader @@ -6737,7 +6737,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, int* top, int* left, Span bottom, int* right) { // SpanOverloader @@ -6745,7 +6745,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, int* top, int* left, Span bottom, Span right) { // SpanOverloader @@ -6753,7 +6753,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, int* top, Span left, int* bottom, int* right) { // SpanOverloader @@ -6761,7 +6761,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, int* top, Span left, int* bottom, Span right) { // SpanOverloader @@ -6769,7 +6769,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, int* top, Span left, Span bottom, int* right) { // SpanOverloader @@ -6777,7 +6777,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, int* top, Span left, Span bottom, Span right) { // SpanOverloader @@ -6785,7 +6785,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, Span top, int* left, int* bottom, int* right) { // SpanOverloader @@ -6793,7 +6793,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, Span top, int* left, int* bottom, Span right) { // SpanOverloader @@ -6801,7 +6801,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, Span top, int* left, Span bottom, int* right) { // SpanOverloader @@ -6809,7 +6809,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, Span top, int* left, Span bottom, Span right) { // SpanOverloader @@ -6817,7 +6817,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, Span top, Span left, int* bottom, int* right) { // SpanOverloader @@ -6825,7 +6825,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, Span top, Span left, int* bottom, Span right) { // SpanOverloader @@ -6833,7 +6833,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, Span top, Span left, Span bottom, int* right) { // SpanOverloader @@ -6841,7 +6841,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1046, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1078, Column 29 in SDL_video.h")] public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, Span top, Span left, Span bottom, Span right) { // SpanOverloader @@ -6849,7 +6849,7 @@ public static unsafe int GetWindowBordersSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1068, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1101, Column 30 in SDL_video.h")] public static unsafe void GetWindowSizeInPixels(this Sdl thisApi, Window* window, int* w, Span h) { // SpanOverloader @@ -6857,7 +6857,7 @@ public static unsafe void GetWindowSizeInPixels(this Sdl thisApi, Window* window } /// To be documented. - [NativeName("Src", "Line 1068, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1101, Column 30 in SDL_video.h")] public static unsafe void GetWindowSizeInPixels(this Sdl thisApi, Window* window, Span w, int* h) { // SpanOverloader @@ -6865,7 +6865,7 @@ public static unsafe void GetWindowSizeInPixels(this Sdl thisApi, Window* window } /// To be documented. - [NativeName("Src", "Line 1068, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1101, Column 30 in SDL_video.h")] public static unsafe void GetWindowSizeInPixels(this Sdl thisApi, Window* window, Span w, Span h) { // SpanOverloader @@ -6873,7 +6873,7 @@ public static unsafe void GetWindowSizeInPixels(this Sdl thisApi, Window* window } /// To be documented. - [NativeName("Src", "Line 1100, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1133, Column 30 in SDL_video.h")] public static unsafe void GetWindowMinimumSize(this Sdl thisApi, Window* window, int* w, Span h) { // SpanOverloader @@ -6881,7 +6881,7 @@ public static unsafe void GetWindowMinimumSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1100, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1133, Column 30 in SDL_video.h")] public static unsafe void GetWindowMinimumSize(this Sdl thisApi, Window* window, Span w, int* h) { // SpanOverloader @@ -6889,7 +6889,7 @@ public static unsafe void GetWindowMinimumSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1100, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1133, Column 30 in SDL_video.h")] public static unsafe void GetWindowMinimumSize(this Sdl thisApi, Window* window, Span w, Span h) { // SpanOverloader @@ -6897,7 +6897,7 @@ public static unsafe void GetWindowMinimumSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1132, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1165, Column 30 in SDL_video.h")] public static unsafe void GetWindowMaximumSize(this Sdl thisApi, Window* window, int* w, Span h) { // SpanOverloader @@ -6905,7 +6905,7 @@ public static unsafe void GetWindowMaximumSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1132, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1165, Column 30 in SDL_video.h")] public static unsafe void GetWindowMaximumSize(this Sdl thisApi, Window* window, Span w, int* h) { // SpanOverloader @@ -6913,7 +6913,7 @@ public static unsafe void GetWindowMaximumSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1132, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 1165, Column 30 in SDL_video.h")] public static unsafe void GetWindowMaximumSize(this Sdl thisApi, Window* window, Span w, Span h) { // SpanOverloader @@ -6921,7 +6921,7 @@ public static unsafe void GetWindowMaximumSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1361, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1402, Column 29 in SDL_video.h")] public static unsafe int UpdateWindowSurfaceRects(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rects, int numrects) { // SpanOverloader @@ -6929,7 +6929,7 @@ public static unsafe int UpdateWindowSurfaceRects(this Sdl thisApi, Window* wind } /// To be documented. - [NativeName("Src", "Line 1515, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1556, Column 29 in SDL_video.h")] public static unsafe int SetWindowMouseRect(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect) { // SpanOverloader @@ -6937,7 +6937,7 @@ public static unsafe int SetWindowMouseRect(this Sdl thisApi, Window* window, [F } /// To be documented. - [NativeName("Src", "Line 1615, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1656, Column 29 in SDL_video.h")] public static unsafe int GetWindowOpacity(this Sdl thisApi, Window* window, Span out_opacity) { // SpanOverloader @@ -6945,7 +6945,7 @@ public static unsafe int GetWindowOpacity(this Sdl thisApi, Window* window, Span } /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan blue) { // SpanOverloader @@ -6953,7 +6953,7 @@ public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [F } /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* blue) { // SpanOverloader @@ -6961,7 +6961,7 @@ public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [F } /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan blue) { // SpanOverloader @@ -6969,7 +6969,7 @@ public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [F } /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* blue) { // SpanOverloader @@ -6977,7 +6977,7 @@ public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [F } /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan blue) { // SpanOverloader @@ -6985,7 +6985,7 @@ public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [F } /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ushort* blue) { // SpanOverloader @@ -6993,7 +6993,7 @@ public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [F } /// To be documented. - [NativeName("Src", "Line 1676, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1717, Column 29 in SDL_video.h")] public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan red, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan green, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan blue) { // SpanOverloader @@ -7001,7 +7001,7 @@ public static unsafe int SetWindowGammaRamp(this Sdl thisApi, Window* window, [F } /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, ushort* red, ushort* green, Span blue) { // SpanOverloader @@ -7009,7 +7009,7 @@ public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, us } /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, ushort* red, Span green, ushort* blue) { // SpanOverloader @@ -7017,7 +7017,7 @@ public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, us } /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, ushort* red, Span green, Span blue) { // SpanOverloader @@ -7025,7 +7025,7 @@ public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, us } /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, Span red, ushort* green, ushort* blue) { // SpanOverloader @@ -7033,7 +7033,7 @@ public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, Sp } /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, Span red, ushort* green, Span blue) { // SpanOverloader @@ -7041,7 +7041,7 @@ public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, Sp } /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, Span red, Span green, ushort* blue) { // SpanOverloader @@ -7049,7 +7049,7 @@ public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, Sp } /// To be documented. - [NativeName("Src", "Line 1704, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1745, Column 29 in SDL_video.h")] public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, Span red, Span green, Span blue) { // SpanOverloader @@ -7057,7 +7057,7 @@ public static unsafe int GetWindowGammaRamp(this Sdl thisApi, Window* window, Sp } /// To be documented. - [NativeName("Src", "Line 1782, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1823, Column 29 in SDL_video.h")] public static unsafe int SetWindowHitTest(this Sdl thisApi, Window* window, PfnHitTest callback, Span callback_data) where T0 : unmanaged { // SpanOverloader @@ -7065,7 +7065,7 @@ public static unsafe int SetWindowHitTest(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 1884, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 1925, Column 29 in SDL_video.h")] public static unsafe int GLLoadLibrary(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan path) { // SpanOverloader @@ -7073,7 +7073,7 @@ public static unsafe int GLLoadLibrary(this Sdl thisApi, [Flow(Silk.NET.Core.Nat } /// To be documented. - [NativeName("Src", "Line 1937, Column 31 in SDL_video.h")] + [NativeName("Src", "Line 1978, Column 31 in SDL_video.h")] public static unsafe void* GLGetProcAddress(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan proc) { // SpanOverloader @@ -7081,7 +7081,7 @@ public static unsafe int GLLoadLibrary(this Sdl thisApi, [Flow(Silk.NET.Core.Nat } /// To be documented. - [NativeName("Src", "Line 1967, Column 34 in SDL_video.h")] + [NativeName("Src", "Line 2008, Column 34 in SDL_video.h")] public static unsafe SdlBool GLExtensionSupported(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan extension) { // SpanOverloader @@ -7089,7 +7089,7 @@ public static unsafe SdlBool GLExtensionSupported(this Sdl thisApi, [Flow(Silk.N } /// To be documented. - [NativeName("Src", "Line 2013, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 2056, Column 29 in SDL_video.h")] public static unsafe int GLGetAttribute(this Sdl thisApi, GLattr attr, Span value) { // SpanOverloader @@ -7097,7 +7097,7 @@ public static unsafe int GLGetAttribute(this Sdl thisApi, GLattr attr, Span } /// To be documented. - [NativeName("Src", "Line 2052, Column 29 in SDL_video.h")] + [NativeName("Src", "Line 2095, Column 29 in SDL_video.h")] public static unsafe int GLMakeCurrent(this Sdl thisApi, Window* window, Span context) where T0 : unmanaged { // SpanOverloader @@ -7105,7 +7105,7 @@ public static unsafe int GLMakeCurrent(this Sdl thisApi, Window* window, Spa } /// To be documented. - [NativeName("Src", "Line 2097, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2141, Column 30 in SDL_video.h")] public static unsafe void GLGetDrawableSize(this Sdl thisApi, Window* window, int* w, Span h) { // SpanOverloader @@ -7113,7 +7113,7 @@ public static unsafe void GLGetDrawableSize(this Sdl thisApi, Window* window, in } /// To be documented. - [NativeName("Src", "Line 2097, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2141, Column 30 in SDL_video.h")] public static unsafe void GLGetDrawableSize(this Sdl thisApi, Window* window, Span w, int* h) { // SpanOverloader @@ -7121,7 +7121,7 @@ public static unsafe void GLGetDrawableSize(this Sdl thisApi, Window* window, Sp } /// To be documented. - [NativeName("Src", "Line 2097, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2141, Column 30 in SDL_video.h")] public static unsafe void GLGetDrawableSize(this Sdl thisApi, Window* window, Span w, Span h) { // SpanOverloader @@ -7129,7 +7129,7 @@ public static unsafe void GLGetDrawableSize(this Sdl thisApi, Window* window, Sp } /// To be documented. - [NativeName("Src", "Line 2171, Column 30 in SDL_video.h")] + [NativeName("Src", "Line 2215, Column 30 in SDL_video.h")] public static unsafe void GLDeleteContext(this Sdl thisApi, Span context) where T0 : unmanaged { // SpanOverloader @@ -7137,7 +7137,7 @@ public static unsafe void GLDeleteContext(this Sdl thisApi, Span context } /// To be documented. - [NativeName("Src", "Line 109, Column 29 in SDL_vulkan.h")] + [NativeName("Src", "Line 113, Column 29 in SDL_vulkan.h")] public static unsafe int VulkanLoadLibrary(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan path) { // SpanOverloader @@ -7145,7 +7145,7 @@ public static unsafe int VulkanLoadLibrary(this Sdl thisApi, [Flow(Silk.NET.Core } /// To be documented. - [NativeName("Src", "Line 160, Column 34 in SDL_vulkan.h")] + [NativeName("Src", "Line 164, Column 34 in SDL_vulkan.h")] public static unsafe SdlBool VulkanGetInstanceExtensions(this Sdl thisApi, Window* window, Span pCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte** pNames) { // SpanOverloader @@ -7153,7 +7153,7 @@ public static unsafe SdlBool VulkanGetInstanceExtensions(this Sdl thisApi, Windo } /// To be documented. - [NativeName("Src", "Line 160, Column 34 in SDL_vulkan.h")] + [NativeName("Src", "Line 164, Column 34 in SDL_vulkan.h")] public static unsafe SdlBool VulkanGetInstanceExtensions(this Sdl thisApi, Window* window, Span pCount, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ref readonly byte* pNames) { // SpanOverloader @@ -7161,7 +7161,7 @@ public static unsafe SdlBool VulkanGetInstanceExtensions(this Sdl thisApi, Windo } /// To be documented. - [NativeName("Src", "Line 182, Column 34 in SDL_vulkan.h")] + [NativeName("Src", "Line 186, Column 34 in SDL_vulkan.h")] public static unsafe SdlBool VulkanCreateSurface(this Sdl thisApi, Window* window, Silk.NET.Core.Native.VkHandle instance, Span surface) { // SpanOverloader @@ -7169,7 +7169,7 @@ public static unsafe SdlBool VulkanCreateSurface(this Sdl thisApi, Window* windo } /// To be documented. - [NativeName("Src", "Line 204, Column 30 in SDL_vulkan.h")] + [NativeName("Src", "Line 208, Column 30 in SDL_vulkan.h")] public static unsafe void VulkanGetDrawableSize(this Sdl thisApi, Window* window, int* w, Span h) { // SpanOverloader @@ -7177,7 +7177,7 @@ public static unsafe void VulkanGetDrawableSize(this Sdl thisApi, Window* window } /// To be documented. - [NativeName("Src", "Line 204, Column 30 in SDL_vulkan.h")] + [NativeName("Src", "Line 208, Column 30 in SDL_vulkan.h")] public static unsafe void VulkanGetDrawableSize(this Sdl thisApi, Window* window, Span w, int* h) { // SpanOverloader @@ -7185,7 +7185,7 @@ public static unsafe void VulkanGetDrawableSize(this Sdl thisApi, Window* window } /// To be documented. - [NativeName("Src", "Line 204, Column 30 in SDL_vulkan.h")] + [NativeName("Src", "Line 208, Column 30 in SDL_vulkan.h")] public static unsafe void VulkanGetDrawableSize(this Sdl thisApi, Window* window, Span w, Span h) { // SpanOverloader @@ -7238,7 +7238,7 @@ public static unsafe int WinRTRunApp(this Sdl thisApi, PfnMainFunc mainFunct } /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg2, int arg3) { // SpanOverloader @@ -7246,7 +7246,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, AssertData* a } /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg2, int arg3) { // SpanOverloader @@ -7254,7 +7254,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, AssertData* a } /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg2, int arg3) { // SpanOverloader @@ -7262,7 +7262,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, AssertData* a } /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg2, int arg3) { // SpanOverloader @@ -7270,7 +7270,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, AssertData* a } /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, AssertData* arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg2, int arg3) { // SpanOverloader @@ -7278,7 +7278,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, AssertData* a } /// To be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, Span arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg2, int arg3) { // SpanOverloader @@ -7286,7 +7286,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, Span arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg2, int arg3) { // SpanOverloader @@ -7294,7 +7294,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, Span arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg2, int arg3) { // SpanOverloader @@ -7302,7 +7302,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, Span arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg2, int arg3) { // SpanOverloader @@ -7310,7 +7310,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, Span arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg2, int arg3) { // SpanOverloader @@ -7318,7 +7318,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, Span arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg2, int arg3) { // SpanOverloader @@ -7326,7 +7326,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, Span arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* arg2, int arg3) { // SpanOverloader @@ -7334,7 +7334,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, Span arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan arg2, int arg3) { // SpanOverloader @@ -7342,7 +7342,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 131, Column 41 in SDL_assert.h")] + [NativeName("Src", "Line 133, Column 41 in SDL_assert.h")] public static unsafe AssertState ReportAssertion(this Sdl thisApi, Span arg0, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg2, int arg3) { // SpanOverloader @@ -7350,7 +7350,7 @@ public static unsafe AssertState ReportAssertion(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 222, Column 30 in SDL_assert.h")] + [NativeName("Src", "Line 224, Column 30 in SDL_assert.h")] public static unsafe void SetAssertionHandler(this Sdl thisApi, PfnAssertionHandler handler, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -7358,7 +7358,7 @@ public static unsafe void SetAssertionHandler(this Sdl thisApi, PfnAssertion } /// To be documented. - [NativeName("Src", "Line 106, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 97, Column 34 in SDL_atomic.h")] public static unsafe SdlBool AtomicTryLock(this Sdl thisApi, Span @lock) { // SpanOverloader @@ -7366,7 +7366,7 @@ public static unsafe SdlBool AtomicTryLock(this Sdl thisApi, Span @lock) } /// To be documented. - [NativeName("Src", "Line 121, Column 30 in SDL_atomic.h")] + [NativeName("Src", "Line 112, Column 30 in SDL_atomic.h")] public static unsafe void AtomicLock(this Sdl thisApi, Span @lock) { // SpanOverloader @@ -7374,7 +7374,7 @@ public static unsafe void AtomicLock(this Sdl thisApi, Span @lock) } /// To be documented. - [NativeName("Src", "Line 138, Column 30 in SDL_atomic.h")] + [NativeName("Src", "Line 129, Column 30 in SDL_atomic.h")] public static unsafe void AtomicUnlock(this Sdl thisApi, Span @lock) { // SpanOverloader @@ -7382,7 +7382,7 @@ public static unsafe void AtomicUnlock(this Sdl thisApi, Span @lock) } /// To be documented. - [NativeName("Src", "Line 282, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 276, Column 34 in SDL_atomic.h")] public static unsafe SdlBool AtomicCAS(this Sdl thisApi, Span a, int oldval, int newval) { // SpanOverloader @@ -7390,7 +7390,7 @@ public static unsafe SdlBool AtomicCAS(this Sdl thisApi, Span a, int ol } /// To be documented. - [NativeName("Src", "Line 300, Column 29 in SDL_atomic.h")] + [NativeName("Src", "Line 294, Column 29 in SDL_atomic.h")] public static unsafe int AtomicSet(this Sdl thisApi, Span a, int v) { // SpanOverloader @@ -7398,7 +7398,7 @@ public static unsafe int AtomicSet(this Sdl thisApi, Span a, int v) } /// To be documented. - [NativeName("Src", "Line 315, Column 29 in SDL_atomic.h")] + [NativeName("Src", "Line 309, Column 29 in SDL_atomic.h")] public static unsafe int AtomicGet(this Sdl thisApi, Span a) { // SpanOverloader @@ -7406,7 +7406,7 @@ public static unsafe int AtomicGet(this Sdl thisApi, Span a) } /// To be documented. - [NativeName("Src", "Line 334, Column 29 in SDL_atomic.h")] + [NativeName("Src", "Line 328, Column 29 in SDL_atomic.h")] public static unsafe int AtomicAdd(this Sdl thisApi, Span a, int v) { // SpanOverloader @@ -7414,7 +7414,7 @@ public static unsafe int AtomicAdd(this Sdl thisApi, Span a, int v) } /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, void** a, void* oldval, Span newval) where T0 : unmanaged { // SpanOverloader @@ -7422,7 +7422,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, void** a, void* } /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, void** a, Span oldval, void* newval) where T0 : unmanaged { // SpanOverloader @@ -7430,7 +7430,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, void** a, SpanTo be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, void** a, Span oldval, Span newval) where T0 : unmanaged where T1 : unmanaged { // SpanOverloader @@ -7438,7 +7438,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, void** a, Sp } /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, void* oldval, Span newval) where T0 : unmanaged { // SpanOverloader @@ -7446,7 +7446,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, voi } /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, Span oldval, void* newval) where T0 : unmanaged { // SpanOverloader @@ -7454,7 +7454,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, Spa } /// To be documented. - [NativeName("Src", "Line 370, Column 34 in SDL_atomic.h")] + [NativeName("Src", "Line 364, Column 34 in SDL_atomic.h")] public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, Span oldval, Span newval) where T0 : unmanaged where T1 : unmanaged { // SpanOverloader @@ -7462,7 +7462,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, } /// To be documented. - [NativeName("Src", "Line 387, Column 31 in SDL_atomic.h")] + [NativeName("Src", "Line 381, Column 31 in SDL_atomic.h")] public static unsafe void* AtomicSetPtr(this Sdl thisApi, void** a, Span v) where T0 : unmanaged { // SpanOverloader @@ -7470,7 +7470,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, } /// To be documented. - [NativeName("Src", "Line 387, Column 31 in SDL_atomic.h")] + [NativeName("Src", "Line 381, Column 31 in SDL_atomic.h")] public static unsafe void* AtomicSetPtr(this Sdl thisApi, ref void* a, Span v) where T0 : unmanaged { // SpanOverloader @@ -7478,7 +7478,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, } /// To be documented. - [NativeName("Src", "Line 208, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 210, Column 1 in SDL_thread.h")] public static unsafe Thread* CreateThread(this Sdl thisApi, PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, Span data) where T0 : unmanaged { // SpanOverloader @@ -7486,7 +7486,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, } /// To be documented. - [NativeName("Src", "Line 208, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 210, Column 1 in SDL_thread.h")] public static unsafe Thread* CreateThread(this Sdl thisApi, PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, void* data) { // SpanOverloader @@ -7494,7 +7494,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, } /// To be documented. - [NativeName("Src", "Line 208, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 210, Column 1 in SDL_thread.h")] public static unsafe Thread* CreateThread(this Sdl thisApi, PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, Span data) where T0 : unmanaged { // SpanOverloader @@ -7502,7 +7502,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, } /// To be documented. - [NativeName("Src", "Line 208, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 210, Column 1 in SDL_thread.h")] public static unsafe Thread* CreateThread(this Sdl thisApi, PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, Span data) where T0 : unmanaged { // SpanOverloader @@ -7510,7 +7510,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, } /// To be documented. - [NativeName("Src", "Line 254, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 256, Column 1 in SDL_thread.h")] public static unsafe Thread* CreateThreadWithStackSize(this Sdl thisApi, PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, nuint stacksize, Span data) where T0 : unmanaged { // SpanOverloader @@ -7518,7 +7518,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, } /// To be documented. - [NativeName("Src", "Line 254, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 256, Column 1 in SDL_thread.h")] public static unsafe Thread* CreateThreadWithStackSize(this Sdl thisApi, PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, nuint stacksize, void* data) { // SpanOverloader @@ -7526,7 +7526,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, } /// To be documented. - [NativeName("Src", "Line 254, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 256, Column 1 in SDL_thread.h")] public static unsafe Thread* CreateThreadWithStackSize(this Sdl thisApi, PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, nuint stacksize, Span data) where T0 : unmanaged { // SpanOverloader @@ -7534,7 +7534,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, } /// To be documented. - [NativeName("Src", "Line 254, Column 1 in SDL_thread.h")] + [NativeName("Src", "Line 256, Column 1 in SDL_thread.h")] public static unsafe Thread* CreateThreadWithStackSize(this Sdl thisApi, PfnThreadFunction fn, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, nuint stacksize, Span data) where T0 : unmanaged { // SpanOverloader @@ -7542,7 +7542,7 @@ public static unsafe SdlBool AtomicCASPtr(this Sdl thisApi, ref void* a, } /// To be documented. - [NativeName("Src", "Line 357, Column 30 in SDL_thread.h")] + [NativeName("Src", "Line 359, Column 30 in SDL_thread.h")] public static unsafe void WaitThread(this Sdl thisApi, Thread* thread, Span status) { // SpanOverloader @@ -7550,7 +7550,7 @@ public static unsafe void WaitThread(this Sdl thisApi, Thread* thread, Span } /// To be documented. - [NativeName("Src", "Line 447, Column 29 in SDL_thread.h")] + [NativeName("Src", "Line 451, Column 29 in SDL_thread.h")] public static unsafe int TLSSet(this Sdl thisApi, uint id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan value, PfnFreeFunc destructor) where T0 : unmanaged { // SpanOverloader @@ -7558,7 +7558,7 @@ public static unsafe int TLSSet(this Sdl thisApi, uint id, [Flow(Silk.NET.Co } /// To be documented. - [NativeName("Src", "Line 325, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 322, Column 29 in SDL_audio.h")] public static unsafe int AudioInit(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan driver_name) { // SpanOverloader @@ -7566,7 +7566,7 @@ public static unsafe int AudioInit(this Sdl thisApi, [Flow(Silk.NET.Core.Native. } /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 404, Column 29 in SDL_audio.h")] public static unsafe int OpenAudio(this Sdl thisApi, AudioSpec* desired, Span obtained) { // SpanOverloader @@ -7574,7 +7574,7 @@ public static unsafe int OpenAudio(this Sdl thisApi, AudioSpec* desired, SpanTo be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 404, Column 29 in SDL_audio.h")] public static unsafe int OpenAudio(this Sdl thisApi, Span desired, AudioSpec* obtained) { // SpanOverloader @@ -7582,7 +7582,7 @@ public static unsafe int OpenAudio(this Sdl thisApi, Span desired, Au } /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 404, Column 29 in SDL_audio.h")] public static unsafe int OpenAudio(this Sdl thisApi, Span desired, Span obtained) { // SpanOverloader @@ -7590,7 +7590,7 @@ public static unsafe int OpenAudio(this Sdl thisApi, Span desired, Sp } /// To be documented. - [NativeName("Src", "Line 518, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 515, Column 29 in SDL_audio.h")] public static unsafe int GetAudioDeviceSpec(this Sdl thisApi, int index, int iscapture, Span spec) { // SpanOverloader @@ -7598,7 +7598,7 @@ public static unsafe int GetAudioDeviceSpec(this Sdl thisApi, int index, int isc } /// To be documented. - [NativeName("Src", "Line 553, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 550, Column 29 in SDL_audio.h")] public static unsafe int GetDefaultAudioInfo(this Sdl thisApi, byte** name, Span spec, int iscapture) { // SpanOverloader @@ -7606,7 +7606,7 @@ public static unsafe int GetDefaultAudioInfo(this Sdl thisApi, byte** name, Span } /// To be documented. - [NativeName("Src", "Line 553, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 550, Column 29 in SDL_audio.h")] public static unsafe int GetDefaultAudioInfo(this Sdl thisApi, ref byte* name, Span spec, int iscapture) { // SpanOverloader @@ -7614,7 +7614,7 @@ public static unsafe int GetDefaultAudioInfo(this Sdl thisApi, ref byte* name, S } /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] AudioSpec* desired, Span obtained, int allowed_changes) { // SpanOverloader @@ -7622,7 +7622,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan desired, AudioSpec* obtained, int allowed_changes) { // SpanOverloader @@ -7630,7 +7630,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan desired, Span obtained, int allowed_changes) { // SpanOverloader @@ -7638,7 +7638,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] AudioSpec* desired, AudioSpec* obtained, int allowed_changes) { // SpanOverloader @@ -7646,7 +7646,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] AudioSpec* desired, Span obtained, int allowed_changes) { // SpanOverloader @@ -7654,7 +7654,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan desired, AudioSpec* obtained, int allowed_changes) { // SpanOverloader @@ -7662,7 +7662,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan desired, Span obtained, int allowed_changes) { // SpanOverloader @@ -7670,7 +7670,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] AudioSpec* desired, Span obtained, int allowed_changes) { // SpanOverloader @@ -7678,7 +7678,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan desired, AudioSpec* obtained, int allowed_changes) { // SpanOverloader @@ -7686,7 +7686,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 669, Column 43 in SDL_audio.h")] + [NativeName("Src", "Line 666, Column 43 in SDL_audio.h")] public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string device, int iscapture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan desired, Span obtained, int allowed_changes) { // SpanOverloader @@ -7694,7 +7694,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, RWops* src, int freesrc, AudioSpec* spec, byte** audio_buf, Span audio_len) { // SpanOverloader @@ -7702,7 +7702,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, RWops* src, int freesrc, AudioSpec* spec, ref byte* audio_buf, Span audio_len) { // SpanOverloader @@ -7710,7 +7710,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, RWops* src, int freesrc, Span spec, byte** audio_buf, uint* audio_len) { // SpanOverloader @@ -7718,7 +7718,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, RWops* src, int freesrc, Span spec, byte** audio_buf, Span audio_len) { // SpanOverloader @@ -7726,7 +7726,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, RWops* src, int freesrc, Span spec, ref byte* audio_buf, uint* audio_len) { // SpanOverloader @@ -7734,7 +7734,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, RWops* src, int freesrc, Span spec, ref byte* audio_buf, Span audio_len) { // SpanOverloader @@ -7742,7 +7742,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, Span src, int freesrc, AudioSpec* spec, byte** audio_buf, uint* audio_len) { // SpanOverloader @@ -7750,7 +7750,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, Span src, int freesrc, AudioSpec* spec, byte** audio_buf, Span audio_len) { // SpanOverloader @@ -7758,7 +7758,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, Span src, int freesrc, AudioSpec* spec, ref byte* audio_buf, uint* audio_len) { // SpanOverloader @@ -7766,7 +7766,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, Span src, int freesrc, AudioSpec* spec, ref byte* audio_buf, Span audio_len) { // SpanOverloader @@ -7774,7 +7774,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, Span src, int freesrc, Span spec, byte** audio_buf, uint* audio_len) { // SpanOverloader @@ -7782,7 +7782,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, Span src, int freesrc, Span spec, byte** audio_buf, Span audio_len) { // SpanOverloader @@ -7790,7 +7790,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, Span src, int freesrc, Span spec, ref byte* audio_buf, uint* audio_len) { // SpanOverloader @@ -7798,7 +7798,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 870, Column 40 in SDL_audio.h")] + [NativeName("Src", "Line 867, Column 40 in SDL_audio.h")] public static unsafe AudioSpec* LoadWAVRW(this Sdl thisApi, Span src, int freesrc, Span spec, ref byte* audio_buf, Span audio_len) { // SpanOverloader @@ -7806,7 +7806,7 @@ public static unsafe uint OpenAudioDevice(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 898, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 896, Column 30 in SDL_audio.h")] public static unsafe void FreeWAV(this Sdl thisApi, Span audio_buf) { // SpanOverloader @@ -7814,7 +7814,7 @@ public static unsafe void FreeWAV(this Sdl thisApi, Span audio_buf) } /// To be documented. - [NativeName("Src", "Line 932, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 931, Column 29 in SDL_audio.h")] public static unsafe int BuildAudioCVT(this Sdl thisApi, Span cvt, ushort src_format, byte src_channels, int src_rate, ushort dst_format, byte dst_channels, int dst_rate) { // SpanOverloader @@ -7822,7 +7822,7 @@ public static unsafe int BuildAudioCVT(this Sdl thisApi, Span cvt, ush } /// To be documented. - [NativeName("Src", "Line 978, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 977, Column 29 in SDL_audio.h")] public static unsafe int ConvertAudio(this Sdl thisApi, Span cvt) { // SpanOverloader @@ -7830,7 +7830,7 @@ public static unsafe int ConvertAudio(this Sdl thisApi, Span cvt) } /// To be documented. - [NativeName("Src", "Line 1035, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 1034, Column 29 in SDL_audio.h")] public static unsafe int AudioStreamPut(this Sdl thisApi, AudioStream* stream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan buf, int len) where T0 : unmanaged { // SpanOverloader @@ -7838,7 +7838,7 @@ public static unsafe int AudioStreamPut(this Sdl thisApi, AudioStream* strea } /// To be documented. - [NativeName("Src", "Line 1054, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 1053, Column 29 in SDL_audio.h")] public static unsafe int AudioStreamGet(this Sdl thisApi, AudioStream* stream, Span buf, int len) where T0 : unmanaged { // SpanOverloader @@ -7846,7 +7846,7 @@ public static unsafe int AudioStreamGet(this Sdl thisApi, AudioStream* strea } /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] public static unsafe void MixAudio(this Sdl thisApi, byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, uint len, int volume) { // SpanOverloader @@ -7854,7 +7854,7 @@ public static unsafe void MixAudio(this Sdl thisApi, byte* dst, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] public static unsafe void MixAudio(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, uint len, int volume) { // SpanOverloader @@ -7862,7 +7862,7 @@ public static unsafe void MixAudio(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] public static unsafe void MixAudio(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, uint len, int volume) { // SpanOverloader @@ -7870,7 +7870,7 @@ public static unsafe void MixAudio(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] public static unsafe void MixAudio(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, uint len, int volume) { // SpanOverloader @@ -7878,7 +7878,7 @@ public static unsafe void MixAudio(this Sdl thisApi, Span dst, [Flow(Silk. } /// To be documented. - [NativeName("Src", "Line 1145, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1147, Column 30 in SDL_audio.h")] public static unsafe void MixAudio(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, uint len, int volume) { // SpanOverloader @@ -7886,7 +7886,7 @@ public static unsafe void MixAudio(this Sdl thisApi, [UnmanagedType(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] public static unsafe void MixAudioFormat(this Sdl thisApi, byte* dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, ushort format, uint len, int volume) { // SpanOverloader @@ -7894,7 +7894,7 @@ public static unsafe void MixAudioFormat(this Sdl thisApi, byte* dst, [Flow(Silk } /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] public static unsafe void MixAudioFormat(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* src, ushort format, uint len, int volume) { // SpanOverloader @@ -7902,7 +7902,7 @@ public static unsafe void MixAudioFormat(this Sdl thisApi, Span dst, [Flow } /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] public static unsafe void MixAudioFormat(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, ushort format, uint len, int volume) { // SpanOverloader @@ -7910,7 +7910,7 @@ public static unsafe void MixAudioFormat(this Sdl thisApi, Span dst, [Flow } /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] public static unsafe void MixAudioFormat(this Sdl thisApi, Span dst, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string src, ushort format, uint len, int volume) { // SpanOverloader @@ -7918,7 +7918,7 @@ public static unsafe void MixAudioFormat(this Sdl thisApi, Span dst, [Flow } /// To be documented. - [NativeName("Src", "Line 1178, Column 30 in SDL_audio.h")] + [NativeName("Src", "Line 1180, Column 30 in SDL_audio.h")] public static unsafe void MixAudioFormat(this Sdl thisApi, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string dst, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan src, ushort format, uint len, int volume) { // SpanOverloader @@ -7926,7 +7926,7 @@ public static unsafe void MixAudioFormat(this Sdl thisApi, [UnmanagedType(Silk.N } /// To be documented. - [NativeName("Src", "Line 1229, Column 29 in SDL_audio.h")] + [NativeName("Src", "Line 1231, Column 29 in SDL_audio.h")] public static unsafe int QueueAudio(this Sdl thisApi, uint dev, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, uint len) where T0 : unmanaged { // SpanOverloader @@ -7934,7 +7934,7 @@ public static unsafe int QueueAudio(this Sdl thisApi, uint dev, [Flow(Silk.N } /// To be documented. - [NativeName("Src", "Line 1277, Column 32 in SDL_audio.h")] + [NativeName("Src", "Line 1279, Column 32 in SDL_audio.h")] public static unsafe uint DequeueAudio(this Sdl thisApi, uint dev, Span data, uint len) where T0 : unmanaged { // SpanOverloader @@ -7958,7 +7958,7 @@ public static unsafe int SetPrimarySelectionText(this Sdl thisApi, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 560, Column 32 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 569, Column 32 in SDL_cpuinfo.h")] public static unsafe void* SIMDRealloc(this Sdl thisApi, Span mem, nuint len) where T0 : unmanaged { // SpanOverloader @@ -7966,7 +7966,7 @@ public static unsafe int SetPrimarySelectionText(this Sdl thisApi, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 584, Column 30 in SDL_cpuinfo.h")] + [NativeName("Src", "Line 593, Column 30 in SDL_cpuinfo.h")] public static unsafe void SIMDFree(this Sdl thisApi, Span ptr) where T0 : unmanaged { // SpanOverloader @@ -7974,7 +7974,7 @@ public static unsafe void SIMDFree(this Sdl thisApi, Span ptr) where T0 } /// To be documented. - [NativeName("Src", "Line 95, Column 38 in SDL_keyboard.h")] + [NativeName("Src", "Line 96, Column 38 in SDL_keyboard.h")] public static unsafe byte* GetKeyboardState(this Sdl thisApi, Span numkeys) { // SpanOverloader @@ -7982,7 +7982,7 @@ public static unsafe void SIMDFree(this Sdl thisApi, Span ptr) where T0 } /// To be documented. - [NativeName("Src", "Line 210, Column 38 in SDL_keyboard.h")] + [NativeName("Src", "Line 211, Column 38 in SDL_keyboard.h")] public static unsafe Scancode GetScancodeFromName(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name) { // SpanOverloader @@ -7990,7 +7990,7 @@ public static unsafe Scancode GetScancodeFromName(this Sdl thisApi, [Flow(Silk.N } /// To be documented. - [NativeName("Src", "Line 244, Column 37 in SDL_keyboard.h")] + [NativeName("Src", "Line 245, Column 37 in SDL_keyboard.h")] public static unsafe int GetKeyFromName(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name) { // SpanOverloader @@ -7998,7 +7998,7 @@ public static unsafe int GetKeyFromName(this Sdl thisApi, [Flow(Silk.NET.Core.Na } /// To be documented. - [NativeName("Src", "Line 320, Column 30 in SDL_keyboard.h")] + [NativeName("Src", "Line 326, Column 30 in SDL_keyboard.h")] public static unsafe void SetTextInputRect(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect) { // SpanOverloader @@ -8126,23 +8126,23 @@ public static unsafe uint GetRelativeMouseState(this Sdl thisApi, Span x, S } /// To be documented. - [NativeName("Src", "Line 74, Column 30 in SDL_guid.h")] - public static unsafe void GUIDToString(this Sdl thisApi, GUID guid, Span pszGUID, int cbGUID) + [NativeName("Src", "Line 81, Column 30 in SDL_guid.h")] + public static unsafe void GUIDToString(this Sdl thisApi, Guid guid, Span pszGUID, int cbGUID) { // SpanOverloader thisApi.GUIDToString(guid, ref pszGUID.GetPinnableReference(), cbGUID); } /// To be documented. - [NativeName("Src", "Line 90, Column 34 in SDL_guid.h")] - public static unsafe GUID GUIDFromString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pchGUID) + [NativeName("Src", "Line 97, Column 34 in SDL_guid.h")] + public static unsafe Guid GUIDFromString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pchGUID) { // SpanOverloader return thisApi.GUIDFromString(in pchGUID.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 404, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 416, Column 29 in SDL_joystick.h")] public static unsafe int JoystickAttachVirtualEx(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan desc) { // SpanOverloader @@ -8150,143 +8150,143 @@ public static unsafe int JoystickAttachVirtualEx(this Sdl thisApi, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 640, Column 30 in SDL_joystick.h")] - public static unsafe void JoystickGetGUIDString(this Sdl thisApi, GUID guid, Span pszGUID, int cbGUID) + [NativeName("Src", "Line 652, Column 30 in SDL_joystick.h")] + public static unsafe void JoystickGetGUIDString(this Sdl thisApi, Guid guid, Span pszGUID, int cbGUID) { // SpanOverloader thisApi.JoystickGetGUIDString(guid, ref pszGUID.GetPinnableReference(), cbGUID); } /// To be documented. - [NativeName("Src", "Line 656, Column 42 in SDL_joystick.h")] - public static unsafe GUID JoystickGetGUIDFromString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pchGUID) + [NativeName("Src", "Line 668, Column 42 in SDL_joystick.h")] + public static unsafe Guid JoystickGetGUIDFromString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pchGUID) { // SpanOverloader return thisApi.JoystickGetGUIDFromString(in pchGUID.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, ushort* vendor, ushort* product, ushort* version, Span crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, ushort* vendor, ushort* product, ushort* version, Span crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, vendor, product, version, ref crc16.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, ushort* vendor, ushort* product, Span version, ushort* crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, ushort* vendor, ushort* product, Span version, ushort* crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, vendor, product, ref version.GetPinnableReference(), crc16); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, ushort* vendor, ushort* product, Span version, Span crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, ushort* vendor, ushort* product, Span version, Span crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, vendor, product, ref version.GetPinnableReference(), ref crc16.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, ushort* vendor, Span product, ushort* version, ushort* crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, ushort* vendor, Span product, ushort* version, ushort* crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, vendor, ref product.GetPinnableReference(), version, crc16); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, ushort* vendor, Span product, ushort* version, Span crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, ushort* vendor, Span product, ushort* version, Span crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, vendor, ref product.GetPinnableReference(), version, ref crc16.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, ushort* vendor, Span product, Span version, ushort* crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, ushort* vendor, Span product, Span version, ushort* crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, vendor, ref product.GetPinnableReference(), ref version.GetPinnableReference(), crc16); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, ushort* vendor, Span product, Span version, Span crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, ushort* vendor, Span product, Span version, Span crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, vendor, ref product.GetPinnableReference(), ref version.GetPinnableReference(), ref crc16.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, Span vendor, ushort* product, ushort* version, ushort* crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, Span vendor, ushort* product, ushort* version, ushort* crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, ref vendor.GetPinnableReference(), product, version, crc16); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, Span vendor, ushort* product, ushort* version, Span crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, Span vendor, ushort* product, ushort* version, Span crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, ref vendor.GetPinnableReference(), product, version, ref crc16.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, Span vendor, ushort* product, Span version, ushort* crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, Span vendor, ushort* product, Span version, ushort* crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, ref vendor.GetPinnableReference(), product, ref version.GetPinnableReference(), crc16); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, Span vendor, ushort* product, Span version, Span crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, Span vendor, ushort* product, Span version, Span crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, ref vendor.GetPinnableReference(), product, ref version.GetPinnableReference(), ref crc16.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, Span vendor, Span product, ushort* version, ushort* crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, Span vendor, Span product, ushort* version, ushort* crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, ref vendor.GetPinnableReference(), ref product.GetPinnableReference(), version, crc16); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, Span vendor, Span product, ushort* version, Span crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, Span vendor, Span product, ushort* version, Span crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, ref vendor.GetPinnableReference(), ref product.GetPinnableReference(), version, ref crc16.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, Span vendor, Span product, Span version, ushort* crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, Span vendor, Span product, Span version, ushort* crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, ref vendor.GetPinnableReference(), ref product.GetPinnableReference(), ref version.GetPinnableReference(), crc16); } /// To be documented. - [NativeName("Src", "Line 675, Column 30 in SDL_joystick.h")] - public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, GUID guid, Span vendor, Span product, Span version, Span crc16) + [NativeName("Src", "Line 687, Column 30 in SDL_joystick.h")] + public static unsafe void GetJoystickGUIDInfo(this Sdl thisApi, Guid guid, Span vendor, Span product, Span version, Span crc16) { // SpanOverloader thisApi.GetJoystickGUIDInfo(guid, ref vendor.GetPinnableReference(), ref product.GetPinnableReference(), ref version.GetPinnableReference(), ref crc16.GetPinnableReference()); } /// To be documented. - [NativeName("Src", "Line 853, Column 34 in SDL_joystick.h")] + [NativeName("Src", "Line 866, Column 34 in SDL_joystick.h")] public static unsafe SdlBool JoystickGetAxisInitialState(this Sdl thisApi, Joystick* joystick, int axis, Span state) { // SpanOverloader @@ -8294,7 +8294,7 @@ public static unsafe SdlBool JoystickGetAxisInitialState(this Sdl thisApi, Joyst } /// To be documented. - [NativeName("Src", "Line 916, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 929, Column 29 in SDL_joystick.h")] public static unsafe int JoystickGetBall(this Sdl thisApi, Joystick* joystick, int ball, int* dx, Span dy) { // SpanOverloader @@ -8302,7 +8302,7 @@ public static unsafe int JoystickGetBall(this Sdl thisApi, Joystick* joystick, i } /// To be documented. - [NativeName("Src", "Line 916, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 929, Column 29 in SDL_joystick.h")] public static unsafe int JoystickGetBall(this Sdl thisApi, Joystick* joystick, int ball, Span dx, int* dy) { // SpanOverloader @@ -8310,7 +8310,7 @@ public static unsafe int JoystickGetBall(this Sdl thisApi, Joystick* joystick, i } /// To be documented. - [NativeName("Src", "Line 916, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 929, Column 29 in SDL_joystick.h")] public static unsafe int JoystickGetBall(this Sdl thisApi, Joystick* joystick, int ball, Span dx, Span dy) { // SpanOverloader @@ -8318,7 +8318,7 @@ public static unsafe int JoystickGetBall(this Sdl thisApi, Joystick* joystick, i } /// To be documented. - [NativeName("Src", "Line 1042, Column 29 in SDL_joystick.h")] + [NativeName("Src", "Line 1056, Column 29 in SDL_joystick.h")] public static unsafe int JoystickSendEffect(this Sdl thisApi, Joystick* joystick, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, int size) where T0 : unmanaged { // SpanOverloader @@ -8326,7 +8326,7 @@ public static unsafe int JoystickSendEffect(this Sdl thisApi, Joystick* joys } /// To be documented. - [NativeName("Src", "Line 270, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 277, Column 29 in SDL_sensor.h")] public static unsafe int SensorGetData(this Sdl thisApi, Sensor* sensor, Span data, int num_values) { // SpanOverloader @@ -8334,7 +8334,7 @@ public static unsafe int SensorGetData(this Sdl thisApi, Sensor* sensor, SpanTo be documented. - [NativeName("Src", "Line 287, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 294, Column 29 in SDL_sensor.h")] public static unsafe int SensorGetDataWithTimestamp(this Sdl thisApi, Sensor* sensor, ulong* timestamp, Span data, int num_values) { // SpanOverloader @@ -8342,7 +8342,7 @@ public static unsafe int SensorGetDataWithTimestamp(this Sdl thisApi, Sensor* se } /// To be documented. - [NativeName("Src", "Line 287, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 294, Column 29 in SDL_sensor.h")] public static unsafe int SensorGetDataWithTimestamp(this Sdl thisApi, Sensor* sensor, Span timestamp, float* data, int num_values) { // SpanOverloader @@ -8350,7 +8350,7 @@ public static unsafe int SensorGetDataWithTimestamp(this Sdl thisApi, Sensor* se } /// To be documented. - [NativeName("Src", "Line 287, Column 29 in SDL_sensor.h")] + [NativeName("Src", "Line 294, Column 29 in SDL_sensor.h")] public static unsafe int SensorGetDataWithTimestamp(this Sdl thisApi, Sensor* sensor, Span timestamp, Span data, int num_values) { // SpanOverloader @@ -8358,7 +8358,7 @@ public static unsafe int SensorGetDataWithTimestamp(this Sdl thisApi, Sensor* se } /// To be documented. - [NativeName("Src", "Line 166, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 173, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerAddMappingsFromRW(this Sdl thisApi, Span rw, int freerw) { // SpanOverloader @@ -8366,7 +8366,7 @@ public static unsafe int GameControllerAddMappingsFromRW(this Sdl thisApi, Span< } /// To be documented. - [NativeName("Src", "Line 202, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 215, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerAddMapping(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan mappingString) { // SpanOverloader @@ -8374,7 +8374,7 @@ public static unsafe int GameControllerAddMapping(this Sdl thisApi, [Flow(Silk.N } /// To be documented. - [NativeName("Src", "Line 652, Column 48 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 667, Column 48 in SDL_gamecontroller.h")] public static unsafe GameControllerAxis GameControllerGetAxisFromString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str) { // SpanOverloader @@ -8382,7 +8382,7 @@ public static unsafe GameControllerAxis GameControllerGetAxisFromString(this Sdl } /// To be documented. - [NativeName("Src", "Line 771, Column 50 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 785, Column 50 in SDL_gamecontroller.h")] public static unsafe GameControllerButton GameControllerGetButtonFromString(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan str) { // SpanOverloader @@ -8390,7 +8390,7 @@ public static unsafe GameControllerButton GameControllerGetButtonFromString(this } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, byte* state, float* x, float* y, Span pressure) { // SpanOverloader @@ -8398,7 +8398,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, byte* state, float* x, Span y, float* pressure) { // SpanOverloader @@ -8406,7 +8406,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, byte* state, float* x, Span y, Span pressure) { // SpanOverloader @@ -8414,7 +8414,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, byte* state, Span x, float* y, float* pressure) { // SpanOverloader @@ -8422,7 +8422,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, byte* state, Span x, float* y, Span pressure) { // SpanOverloader @@ -8430,7 +8430,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, byte* state, Span x, Span y, float* pressure) { // SpanOverloader @@ -8438,7 +8438,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, byte* state, Span x, Span y, Span pressure) { // SpanOverloader @@ -8446,7 +8446,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, Span state, float* x, float* y, float* pressure) { // SpanOverloader @@ -8454,7 +8454,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, Span state, float* x, float* y, Span pressure) { // SpanOverloader @@ -8462,7 +8462,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, Span state, float* x, Span y, float* pressure) { // SpanOverloader @@ -8470,7 +8470,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, Span state, float* x, Span y, Span pressure) { // SpanOverloader @@ -8478,7 +8478,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, Span state, Span x, float* y, float* pressure) { // SpanOverloader @@ -8486,7 +8486,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, Span state, Span x, float* y, Span pressure) { // SpanOverloader @@ -8494,7 +8494,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, Span state, Span x, Span y, float* pressure) { // SpanOverloader @@ -8502,7 +8502,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, Span state, Span x, Span y, Span pressure) { // SpanOverloader @@ -8510,7 +8510,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, float* x, float* y, Span pressure) { // SpanOverloader @@ -8518,7 +8518,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, float* x, Span y, float* pressure) { // SpanOverloader @@ -8526,7 +8526,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, float* x, Span y, Span pressure) { // SpanOverloader @@ -8534,7 +8534,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, Span x, float* y, float* pressure) { // SpanOverloader @@ -8542,7 +8542,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, Span x, float* y, Span pressure) { // SpanOverloader @@ -8550,7 +8550,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, Span x, Span y, float* pressure) { // SpanOverloader @@ -8558,7 +8558,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 856, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 870, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameController* gamecontroller, int touchpad, int finger, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string state, Span x, Span y, Span pressure) { // SpanOverloader @@ -8566,7 +8566,7 @@ public static unsafe int GameControllerGetTouchpadFinger(this Sdl thisApi, GameC } /// To be documented. - [NativeName("Src", "Line 918, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 932, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetSensorData(this Sdl thisApi, GameController* gamecontroller, SensorType type, Span data, int num_values) { // SpanOverloader @@ -8574,7 +8574,7 @@ public static unsafe int GameControllerGetSensorData(this Sdl thisApi, GameContr } /// To be documented. - [NativeName("Src", "Line 937, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 951, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetSensorDataWithTimestamp(this Sdl thisApi, GameController* gamecontroller, SensorType type, ulong* timestamp, Span data, int num_values) { // SpanOverloader @@ -8582,7 +8582,7 @@ public static unsafe int GameControllerGetSensorDataWithTimestamp(this Sdl thisA } /// To be documented. - [NativeName("Src", "Line 937, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 951, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetSensorDataWithTimestamp(this Sdl thisApi, GameController* gamecontroller, SensorType type, Span timestamp, float* data, int num_values) { // SpanOverloader @@ -8590,7 +8590,7 @@ public static unsafe int GameControllerGetSensorDataWithTimestamp(this Sdl thisA } /// To be documented. - [NativeName("Src", "Line 937, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 951, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerGetSensorDataWithTimestamp(this Sdl thisApi, GameController* gamecontroller, SensorType type, Span timestamp, Span data, int num_values) { // SpanOverloader @@ -8598,7 +8598,7 @@ public static unsafe int GameControllerGetSensorDataWithTimestamp(this Sdl thisA } /// To be documented. - [NativeName("Src", "Line 1045, Column 29 in SDL_gamecontroller.h")] + [NativeName("Src", "Line 1059, Column 29 in SDL_gamecontroller.h")] public static unsafe int GameControllerSendEffect(this Sdl thisApi, GameController* gamecontroller, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, int size) where T0 : unmanaged { // SpanOverloader @@ -8630,7 +8630,7 @@ public static unsafe int LoadDollarTemplates(this Sdl thisApi, long touchId, Spa } /// To be documented. - [NativeName("Src", "Line 744, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 781, Column 29 in SDL_events.h")] public static unsafe int PeepEvents(this Sdl thisApi, Span events, int numevents, Eventaction action, uint minType, uint maxType) { // SpanOverloader @@ -8638,7 +8638,7 @@ public static unsafe int PeepEvents(this Sdl thisApi, Span events, int nu } /// To be documented. - [NativeName("Src", "Line 876, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 913, Column 29 in SDL_events.h")] public static unsafe int PollEvent(this Sdl thisApi, Span @event) { // SpanOverloader @@ -8646,7 +8646,7 @@ public static unsafe int PollEvent(this Sdl thisApi, Span @event) } /// To be documented. - [NativeName("Src", "Line 898, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 935, Column 29 in SDL_events.h")] public static unsafe int WaitEvent(this Sdl thisApi, Span @event) { // SpanOverloader @@ -8654,7 +8654,7 @@ public static unsafe int WaitEvent(this Sdl thisApi, Span @event) } /// To be documented. - [NativeName("Src", "Line 924, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 961, Column 29 in SDL_events.h")] public static unsafe int WaitEventTimeout(this Sdl thisApi, Span @event, int timeout) { // SpanOverloader @@ -8662,7 +8662,7 @@ public static unsafe int WaitEventTimeout(this Sdl thisApi, Span @event, } /// To be documented. - [NativeName("Src", "Line 959, Column 29 in SDL_events.h")] + [NativeName("Src", "Line 996, Column 29 in SDL_events.h")] public static unsafe int PushEvent(this Sdl thisApi, Span @event) { // SpanOverloader @@ -8670,7 +8670,7 @@ public static unsafe int PushEvent(this Sdl thisApi, Span @event) } /// To be documented. - [NativeName("Src", "Line 1017, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1054, Column 30 in SDL_events.h")] public static unsafe void SetEventFilter(this Sdl thisApi, PfnEventFilter filter, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -8678,7 +8678,7 @@ public static unsafe void SetEventFilter(this Sdl thisApi, PfnEventFilter fi } /// To be documented. - [NativeName("Src", "Line 1035, Column 34 in SDL_events.h")] + [NativeName("Src", "Line 1072, Column 34 in SDL_events.h")] public static unsafe SdlBool GetEventFilter(this Sdl thisApi, Span filter, void** userdata) { // SpanOverloader @@ -8686,7 +8686,7 @@ public static unsafe SdlBool GetEventFilter(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 1035, Column 34 in SDL_events.h")] + [NativeName("Src", "Line 1072, Column 34 in SDL_events.h")] public static unsafe SdlBool GetEventFilter(this Sdl thisApi, Span filter, ref void* userdata) { // SpanOverloader @@ -8694,7 +8694,7 @@ public static unsafe SdlBool GetEventFilter(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 1064, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1101, Column 30 in SDL_events.h")] public static unsafe void AddEventWatch(this Sdl thisApi, PfnEventFilter filter, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -8702,7 +8702,7 @@ public static unsafe void AddEventWatch(this Sdl thisApi, PfnEventFilter fil } /// To be documented. - [NativeName("Src", "Line 1080, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1117, Column 30 in SDL_events.h")] public static unsafe void DelEventWatch(this Sdl thisApi, PfnEventFilter filter, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -8710,7 +8710,7 @@ public static unsafe void DelEventWatch(this Sdl thisApi, PfnEventFilter fil } /// To be documented. - [NativeName("Src", "Line 1099, Column 30 in SDL_events.h")] + [NativeName("Src", "Line 1136, Column 30 in SDL_events.h")] public static unsafe void FilterEvents(this Sdl thisApi, PfnEventFilter filter, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -8758,7 +8758,7 @@ public static unsafe void FilterEvents(this Sdl thisApi, PfnEventFilter filt } /// To be documented. - [NativeName("Src", "Line 1058, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1070, Column 29 in SDL_haptic.h")] public static unsafe int HapticEffectSupported(this Sdl thisApi, Haptic* haptic, Span effect) { // SpanOverloader @@ -8766,7 +8766,7 @@ public static unsafe int HapticEffectSupported(this Sdl thisApi, Haptic* haptic, } /// To be documented. - [NativeName("Src", "Line 1077, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1089, Column 29 in SDL_haptic.h")] public static unsafe int HapticNewEffect(this Sdl thisApi, Haptic* haptic, Span effect) { // SpanOverloader @@ -8774,7 +8774,7 @@ public static unsafe int HapticNewEffect(this Sdl thisApi, Haptic* haptic, Span< } /// To be documented. - [NativeName("Src", "Line 1101, Column 29 in SDL_haptic.h")] + [NativeName("Src", "Line 1113, Column 29 in SDL_haptic.h")] public static unsafe int HapticUpdateEffect(this Sdl thisApi, Haptic* haptic, int effect, Span data) { // SpanOverloader @@ -8782,7 +8782,7 @@ public static unsafe int HapticUpdateEffect(this Sdl thisApi, Haptic* haptic, in } /// To be documented. - [NativeName("Src", "Line 211, Column 30 in SDL_hidapi.h")] + [NativeName("Src", "Line 203, Column 30 in SDL_hidapi.h")] public static unsafe void HidFreeEnumeration(this Sdl thisApi, Span devs) { // SpanOverloader @@ -8790,7 +8790,7 @@ public static unsafe void HidFreeEnumeration(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 229, Column 42 in SDL_hidapi.h")] + [NativeName("Src", "Line 221, Column 42 in SDL_hidapi.h")] public static unsafe HidDevice* HidOpen(this Sdl thisApi, ushort vendor_id, ushort product_id, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan serial_number) { // SpanOverloader @@ -8798,7 +8798,7 @@ public static unsafe void HidFreeEnumeration(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 243, Column 42 in SDL_hidapi.h")] + [NativeName("Src", "Line 235, Column 42 in SDL_hidapi.h")] public static unsafe HidDevice* HidOpenPath(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan path, int bExclusive) { // SpanOverloader @@ -8806,7 +8806,7 @@ public static unsafe void HidFreeEnumeration(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 269, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 261, Column 29 in SDL_hidapi.h")] public static unsafe int HidWrite(this Sdl thisApi, HidDevice* dev, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint length) { // SpanOverloader @@ -8814,7 +8814,7 @@ public static unsafe int HidWrite(this Sdl thisApi, HidDevice* dev, [Flow(Silk.N } /// To be documented. - [NativeName("Src", "Line 290, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 282, Column 29 in SDL_hidapi.h")] public static unsafe int HidReadTimeout(this Sdl thisApi, HidDevice* dev, Span data, nuint length, int milliseconds) { // SpanOverloader @@ -8822,7 +8822,7 @@ public static unsafe int HidReadTimeout(this Sdl thisApi, HidDevice* dev, SpanTo be documented. - [NativeName("Src", "Line 310, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 302, Column 29 in SDL_hidapi.h")] public static unsafe int HidRead(this Sdl thisApi, HidDevice* dev, Span data, nuint length) { // SpanOverloader @@ -8830,7 +8830,7 @@ public static unsafe int HidRead(this Sdl thisApi, HidDevice* dev, Span da } /// To be documented. - [NativeName("Src", "Line 352, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 344, Column 29 in SDL_hidapi.h")] public static unsafe int HidSendFeatureReport(this Sdl thisApi, HidDevice* dev, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan data, nuint length) { // SpanOverloader @@ -8838,7 +8838,7 @@ public static unsafe int HidSendFeatureReport(this Sdl thisApi, HidDevice* dev, } /// To be documented. - [NativeName("Src", "Line 374, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 366, Column 29 in SDL_hidapi.h")] public static unsafe int HidGetFeatureReport(this Sdl thisApi, HidDevice* dev, Span data, nuint length) { // SpanOverloader @@ -8846,7 +8846,7 @@ public static unsafe int HidGetFeatureReport(this Sdl thisApi, HidDevice* dev, S } /// To be documented. - [NativeName("Src", "Line 395, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_hidapi.h")] public static unsafe int HidGetManufacturerString(this Sdl thisApi, HidDevice* dev, Span @string, nuint maxlen) { // SpanOverloader @@ -8854,7 +8854,7 @@ public static unsafe int HidGetManufacturerString(this Sdl thisApi, HidDevice* d } /// To be documented. - [NativeName("Src", "Line 407, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 399, Column 29 in SDL_hidapi.h")] public static unsafe int HidGetProductString(this Sdl thisApi, HidDevice* dev, Span @string, nuint maxlen) { // SpanOverloader @@ -8862,7 +8862,7 @@ public static unsafe int HidGetProductString(this Sdl thisApi, HidDevice* dev, S } /// To be documented. - [NativeName("Src", "Line 419, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 411, Column 29 in SDL_hidapi.h")] public static unsafe int HidGetSerialNumberString(this Sdl thisApi, HidDevice* dev, Span @string, nuint maxlen) { // SpanOverloader @@ -8870,7 +8870,7 @@ public static unsafe int HidGetSerialNumberString(this Sdl thisApi, HidDevice* d } /// To be documented. - [NativeName("Src", "Line 432, Column 29 in SDL_hidapi.h")] + [NativeName("Src", "Line 424, Column 29 in SDL_hidapi.h")] public static unsafe int HidGetIndexedString(this Sdl thisApi, HidDevice* dev, int string_index, Span @string, nuint maxlen) { // SpanOverloader @@ -8878,7 +8878,7 @@ public static unsafe int HidGetIndexedString(this Sdl thisApi, HidDevice* dev, i } /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] public static unsafe SdlBool SetHintWithPriority(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan value, HintPriority priority) { // SpanOverloader @@ -8886,7 +8886,7 @@ public static unsafe SdlBool SetHintWithPriority(this Sdl thisApi, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] public static unsafe SdlBool SetHintWithPriority(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value, HintPriority priority) { // SpanOverloader @@ -8894,7 +8894,7 @@ public static unsafe SdlBool SetHintWithPriority(this Sdl thisApi, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] public static unsafe SdlBool SetHintWithPriority(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan value, HintPriority priority) { // SpanOverloader @@ -8902,7 +8902,7 @@ public static unsafe SdlBool SetHintWithPriority(this Sdl thisApi, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] public static unsafe SdlBool SetHintWithPriority(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value, HintPriority priority) { // SpanOverloader @@ -8910,7 +8910,7 @@ public static unsafe SdlBool SetHintWithPriority(this Sdl thisApi, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 2743, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3153, Column 34 in SDL_hints.h")] public static unsafe SdlBool SetHintWithPriority(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan value, HintPriority priority) { // SpanOverloader @@ -8918,7 +8918,7 @@ public static unsafe SdlBool SetHintWithPriority(this Sdl thisApi, [Flow(Silk.NE } /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] public static unsafe SdlBool SetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan value) { // SpanOverloader @@ -8926,7 +8926,7 @@ public static unsafe SdlBool SetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] public static unsafe SdlBool SetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* value) { // SpanOverloader @@ -8934,7 +8934,7 @@ public static unsafe SdlBool SetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] public static unsafe SdlBool SetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan value) { // SpanOverloader @@ -8942,7 +8942,7 @@ public static unsafe SdlBool SetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] public static unsafe SdlBool SetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string value) { // SpanOverloader @@ -8950,7 +8950,7 @@ public static unsafe SdlBool SetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 2763, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3173, Column 34 in SDL_hints.h")] public static unsafe SdlBool SetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan value) { // SpanOverloader @@ -8958,7 +8958,7 @@ public static unsafe SdlBool SetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Nativ } /// To be documented. - [NativeName("Src", "Line 2781, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3191, Column 34 in SDL_hints.h")] public static unsafe SdlBool ResetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name) { // SpanOverloader @@ -8966,7 +8966,7 @@ public static unsafe SdlBool ResetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Nat } /// To be documented. - [NativeName("Src", "Line 2809, Column 38 in SDL_hints.h")] + [NativeName("Src", "Line 3219, Column 38 in SDL_hints.h")] public static unsafe byte* GetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name) { // SpanOverloader @@ -8974,7 +8974,7 @@ public static unsafe SdlBool ResetHint(this Sdl thisApi, [Flow(Silk.NET.Core.Nat } /// To be documented. - [NativeName("Src", "Line 2824, Column 34 in SDL_hints.h")] + [NativeName("Src", "Line 3234, Column 34 in SDL_hints.h")] public static unsafe SdlBool GetHintBoolean(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, SdlBool default_value) { // SpanOverloader @@ -8982,7 +8982,7 @@ public static unsafe SdlBool GetHintBoolean(this Sdl thisApi, [Flow(Silk.NET.Cor } /// To be documented. - [NativeName("Src", "Line 2848, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3258, Column 30 in SDL_hints.h")] public static unsafe void AddHintCallback(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, PfnHintCallback callback, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -8990,7 +8990,7 @@ public static unsafe void AddHintCallback(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 2848, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3258, Column 30 in SDL_hints.h")] public static unsafe void AddHintCallback(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, PfnHintCallback callback, void* userdata) { // SpanOverloader @@ -8998,7 +8998,7 @@ public static unsafe void AddHintCallback(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 2848, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3258, Column 30 in SDL_hints.h")] public static unsafe void AddHintCallback(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, PfnHintCallback callback, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -9006,7 +9006,7 @@ public static unsafe void AddHintCallback(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 2848, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3258, Column 30 in SDL_hints.h")] public static unsafe void AddHintCallback(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, PfnHintCallback callback, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -9014,7 +9014,7 @@ public static unsafe void AddHintCallback(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 2864, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3274, Column 30 in SDL_hints.h")] public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name, PfnHintCallback callback, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -9022,7 +9022,7 @@ public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 2864, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3274, Column 30 in SDL_hints.h")] public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, PfnHintCallback callback, void* userdata) { // SpanOverloader @@ -9030,7 +9030,7 @@ public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.Core. } /// To be documented. - [NativeName("Src", "Line 2864, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3274, Column 30 in SDL_hints.h")] public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name, PfnHintCallback callback, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -9038,7 +9038,7 @@ public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 2864, Column 30 in SDL_hints.h")] + [NativeName("Src", "Line 3274, Column 30 in SDL_hints.h")] public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name, PfnHintCallback callback, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -9046,7 +9046,7 @@ public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 65, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 67, Column 31 in SDL_loadso.h")] public static unsafe void* LoadObject(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan sofile) { // SpanOverloader @@ -9054,7 +9054,7 @@ public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 92, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 94, Column 31 in SDL_loadso.h")] public static unsafe void* LoadFunction(this Sdl thisApi, void* handle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name) { // SpanOverloader @@ -9062,7 +9062,7 @@ public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 92, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 94, Column 31 in SDL_loadso.h")] public static unsafe void* LoadFunction(this Sdl thisApi, Span handle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* name) where T0 : unmanaged { // SpanOverloader @@ -9070,7 +9070,7 @@ public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 92, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 94, Column 31 in SDL_loadso.h")] public static unsafe void* LoadFunction(this Sdl thisApi, Span handle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan name) where T0 : unmanaged { // SpanOverloader @@ -9078,7 +9078,7 @@ public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 92, Column 31 in SDL_loadso.h")] + [NativeName("Src", "Line 94, Column 31 in SDL_loadso.h")] public static unsafe void* LoadFunction(this Sdl thisApi, Span handle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string name) where T0 : unmanaged { // SpanOverloader @@ -9086,7 +9086,7 @@ public static unsafe void DelHintCallback(this Sdl thisApi, [Flow(Silk.NET.C } /// To be documented. - [NativeName("Src", "Line 105, Column 30 in SDL_loadso.h")] + [NativeName("Src", "Line 107, Column 30 in SDL_loadso.h")] public static unsafe void UnloadObject(this Sdl thisApi, Span handle) where T0 : unmanaged { // SpanOverloader @@ -9198,7 +9198,7 @@ public static unsafe void LogMessageV(this Sdl thisApi, int category, LogPriorit } /// To be documented. - [NativeName("Src", "Line 381, Column 30 in SDL_log.h")] + [NativeName("Src", "Line 382, Column 30 in SDL_log.h")] public static unsafe void LogGetOutputFunction(this Sdl thisApi, Span callback, void** userdata) { // SpanOverloader @@ -9206,7 +9206,7 @@ public static unsafe void LogGetOutputFunction(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 381, Column 30 in SDL_log.h")] + [NativeName("Src", "Line 382, Column 30 in SDL_log.h")] public static unsafe void LogGetOutputFunction(this Sdl thisApi, Span callback, ref void* userdata) { // SpanOverloader @@ -9214,7 +9214,7 @@ public static unsafe void LogGetOutputFunction(this Sdl thisApi, SpanTo be documented. - [NativeName("Src", "Line 393, Column 30 in SDL_log.h")] + [NativeName("Src", "Line 394, Column 30 in SDL_log.h")] public static unsafe void LogSetOutputFunction(this Sdl thisApi, PfnLogOutputFunction callback, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -9222,7 +9222,7 @@ public static unsafe void LogSetOutputFunction(this Sdl thisApi, PfnLogOutpu } /// To be documented. - [NativeName("Src", "Line 140, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 143, Column 29 in SDL_messagebox.h")] public static unsafe int ShowMessageBox(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MessageBoxData* messageboxdata, Span buttonid) { // SpanOverloader @@ -9230,7 +9230,7 @@ public static unsafe int ShowMessageBox(this Sdl thisApi, [Flow(Silk.NET.Core.Na } /// To be documented. - [NativeName("Src", "Line 140, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 143, Column 29 in SDL_messagebox.h")] public static unsafe int ShowMessageBox(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan messageboxdata, int* buttonid) { // SpanOverloader @@ -9238,7 +9238,7 @@ public static unsafe int ShowMessageBox(this Sdl thisApi, [Flow(Silk.NET.Core.Na } /// To be documented. - [NativeName("Src", "Line 140, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 143, Column 29 in SDL_messagebox.h")] public static unsafe int ShowMessageBox(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan messageboxdata, Span buttonid) { // SpanOverloader @@ -9246,7 +9246,7 @@ public static unsafe int ShowMessageBox(this Sdl thisApi, [Flow(Silk.NET.Core.Na } /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] public static unsafe int ShowSimpleMessageBox(this Sdl thisApi, uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* title, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan message, Window* window) { // SpanOverloader @@ -9254,7 +9254,7 @@ public static unsafe int ShowSimpleMessageBox(this Sdl thisApi, uint flags, [Flo } /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] public static unsafe int ShowSimpleMessageBox(this Sdl thisApi, uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan title, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* message, Window* window) { // SpanOverloader @@ -9262,7 +9262,7 @@ public static unsafe int ShowSimpleMessageBox(this Sdl thisApi, uint flags, [Flo } /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] public static unsafe int ShowSimpleMessageBox(this Sdl thisApi, uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan title, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan message, Window* window) { // SpanOverloader @@ -9270,7 +9270,7 @@ public static unsafe int ShowSimpleMessageBox(this Sdl thisApi, uint flags, [Flo } /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] public static unsafe int ShowSimpleMessageBox(this Sdl thisApi, uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan title, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string message, Window* window) { // SpanOverloader @@ -9278,7 +9278,7 @@ public static unsafe int ShowSimpleMessageBox(this Sdl thisApi, uint flags, [Flo } /// To be documented. - [NativeName("Src", "Line 182, Column 29 in SDL_messagebox.h")] + [NativeName("Src", "Line 185, Column 29 in SDL_messagebox.h")] public static unsafe int ShowSimpleMessageBox(this Sdl thisApi, uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string title, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan message, Window* window) { // SpanOverloader @@ -9286,7 +9286,7 @@ public static unsafe int ShowSimpleMessageBox(this Sdl thisApi, uint flags, [Flo } /// To be documented. - [NativeName("Src", "Line 78, Column 30 in SDL_metal.h")] + [NativeName("Src", "Line 79, Column 30 in SDL_metal.h")] public static unsafe void MetalDestroyView(this Sdl thisApi, Span view) where T0 : unmanaged { // SpanOverloader @@ -9294,7 +9294,7 @@ public static unsafe void MetalDestroyView(this Sdl thisApi, Span view) } /// To be documented. - [NativeName("Src", "Line 87, Column 31 in SDL_metal.h")] + [NativeName("Src", "Line 88, Column 31 in SDL_metal.h")] public static unsafe void* MetalGetLayer(this Sdl thisApi, Span view) where T0 : unmanaged { // SpanOverloader @@ -9302,7 +9302,7 @@ public static unsafe void MetalDestroyView(this Sdl thisApi, Span view) } /// To be documented. - [NativeName("Src", "Line 102, Column 30 in SDL_metal.h")] + [NativeName("Src", "Line 103, Column 30 in SDL_metal.h")] public static unsafe void MetalGetDrawableSize(this Sdl thisApi, Window* window, int* w, Span h) { // SpanOverloader @@ -9310,7 +9310,7 @@ public static unsafe void MetalGetDrawableSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 102, Column 30 in SDL_metal.h")] + [NativeName("Src", "Line 103, Column 30 in SDL_metal.h")] public static unsafe void MetalGetDrawableSize(this Sdl thisApi, Window* window, Span w, int* h) { // SpanOverloader @@ -9318,7 +9318,7 @@ public static unsafe void MetalGetDrawableSize(this Sdl thisApi, Window* window, } /// To be documented. - [NativeName("Src", "Line 102, Column 30 in SDL_metal.h")] + [NativeName("Src", "Line 103, Column 30 in SDL_metal.h")] public static unsafe void MetalGetDrawableSize(this Sdl thisApi, Window* window, Span w, Span h) { // SpanOverloader @@ -9350,7 +9350,7 @@ public static unsafe PowerState GetPowerInfo(this Sdl thisApi, Span seconds } /// To be documented. - [NativeName("Src", "Line 185, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 186, Column 29 in SDL_render.h")] public static unsafe int GetRenderDriverInfo(this Sdl thisApi, int index, Span info) { // SpanOverloader @@ -9358,7 +9358,7 @@ public static unsafe int GetRenderDriverInfo(this Sdl thisApi, int index, SpanTo be documented. - [NativeName("Src", "Line 249, Column 40 in SDL_render.h")] + [NativeName("Src", "Line 250, Column 40 in SDL_render.h")] public static unsafe Renderer* CreateSoftwareRenderer(this Sdl thisApi, Span surface) { // SpanOverloader @@ -9366,7 +9366,7 @@ public static unsafe int GetRenderDriverInfo(this Sdl thisApi, int index, SpanTo be documented. - [NativeName("Src", "Line 288, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 289, Column 29 in SDL_render.h")] public static unsafe int GetRendererInfo(this Sdl thisApi, Renderer* renderer, Span info) { // SpanOverloader @@ -9374,7 +9374,7 @@ public static unsafe int GetRendererInfo(this Sdl thisApi, Renderer* renderer, S } /// To be documented. - [NativeName("Src", "Line 308, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 309, Column 29 in SDL_render.h")] public static unsafe int GetRendererOutputSize(this Sdl thisApi, Renderer* renderer, int* w, Span h) { // SpanOverloader @@ -9382,7 +9382,7 @@ public static unsafe int GetRendererOutputSize(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 308, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 309, Column 29 in SDL_render.h")] public static unsafe int GetRendererOutputSize(this Sdl thisApi, Renderer* renderer, Span w, int* h) { // SpanOverloader @@ -9390,7 +9390,7 @@ public static unsafe int GetRendererOutputSize(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 308, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 309, Column 29 in SDL_render.h")] public static unsafe int GetRendererOutputSize(this Sdl thisApi, Renderer* renderer, Span w, Span h) { // SpanOverloader @@ -9398,7 +9398,7 @@ public static unsafe int GetRendererOutputSize(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 362, Column 39 in SDL_render.h")] + [NativeName("Src", "Line 363, Column 39 in SDL_render.h")] public static unsafe Texture* CreateTextureFromSurface(this Sdl thisApi, Renderer* renderer, Span surface) { // SpanOverloader @@ -9406,7 +9406,7 @@ public static unsafe int GetRendererOutputSize(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* format, int* access, int* w, Span h) { // SpanOverloader @@ -9414,7 +9414,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* } /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* format, int* access, Span w, int* h) { // SpanOverloader @@ -9422,7 +9422,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* } /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* format, int* access, Span w, Span h) { // SpanOverloader @@ -9430,7 +9430,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* } /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* format, Span access, int* w, int* h) { // SpanOverloader @@ -9438,7 +9438,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* } /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* format, Span access, int* w, Span h) { // SpanOverloader @@ -9446,7 +9446,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* } /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* format, Span access, Span w, int* h) { // SpanOverloader @@ -9454,7 +9454,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* } /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* format, Span access, Span w, Span h) { // SpanOverloader @@ -9462,7 +9462,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, uint* } /// To be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, Span format, int* access, int* w, int* h) { // SpanOverloader @@ -9470,7 +9470,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, SpanTo be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, Span format, int* access, int* w, Span h) { // SpanOverloader @@ -9478,7 +9478,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, SpanTo be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, Span format, int* access, Span w, int* h) { // SpanOverloader @@ -9486,7 +9486,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, SpanTo be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, Span format, int* access, Span w, Span h) { // SpanOverloader @@ -9494,7 +9494,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, SpanTo be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, Span format, Span access, int* w, int* h) { // SpanOverloader @@ -9502,7 +9502,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, SpanTo be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, Span format, Span access, int* w, Span h) { // SpanOverloader @@ -9510,7 +9510,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, SpanTo be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, Span format, Span access, Span w, int* h) { // SpanOverloader @@ -9518,7 +9518,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, SpanTo be documented. - [NativeName("Src", "Line 386, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 387, Column 29 in SDL_render.h")] public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, Span format, Span access, Span w, Span h) { // SpanOverloader @@ -9526,7 +9526,7 @@ public static unsafe int QueryTexture(this Sdl thisApi, Texture* texture, SpanTo be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, byte* r, byte* g, Span b) { // SpanOverloader @@ -9534,7 +9534,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, byte* r, Span g, byte* b) { // SpanOverloader @@ -9542,7 +9542,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, byte* r, Span g, Span b) { // SpanOverloader @@ -9550,7 +9550,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -9558,7 +9558,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -9566,7 +9566,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, Span r, byte* g, byte* b) { // SpanOverloader @@ -9574,7 +9574,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, Span r, byte* g, Span b) { // SpanOverloader @@ -9582,7 +9582,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -9590,7 +9590,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, Span r, Span g, byte* b) { // SpanOverloader @@ -9598,7 +9598,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, Span r, Span g, Span b) { // SpanOverloader @@ -9606,7 +9606,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -9614,7 +9614,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b) { // SpanOverloader @@ -9622,7 +9622,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -9630,7 +9630,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -9638,7 +9638,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b) { // SpanOverloader @@ -9646,7 +9646,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b) { // SpanOverloader @@ -9654,7 +9654,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b) { // SpanOverloader @@ -9662,7 +9662,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b) { // SpanOverloader @@ -9670,7 +9670,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 433, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 434, Column 29 in SDL_render.h")] public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b) { // SpanOverloader @@ -9678,7 +9678,7 @@ public static unsafe int GetTextureColorMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 474, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 475, Column 29 in SDL_render.h")] public static unsafe int GetTextureAlphaMod(this Sdl thisApi, Texture* texture, Span alpha) { // SpanOverloader @@ -9686,7 +9686,7 @@ public static unsafe int GetTextureAlphaMod(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 508, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 509, Column 29 in SDL_render.h")] public static unsafe int GetTextureBlendMode(this Sdl thisApi, Texture* texture, Span blendMode) { // SpanOverloader @@ -9694,7 +9694,7 @@ public static unsafe int GetTextureBlendMode(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 538, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 539, Column 29 in SDL_render.h")] public static unsafe int GetTextureScaleMode(this Sdl thisApi, Texture* texture, Span scaleMode) { // SpanOverloader @@ -9702,7 +9702,7 @@ public static unsafe int GetTextureScaleMode(this Sdl thisApi, Texture* texture, } /// To be documented. - [NativeName("Src", "Line 552, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 553, Column 29 in SDL_render.h")] public static unsafe int SetTextureUserData(this Sdl thisApi, Texture* texture, Span userdata) where T0 : unmanaged { // SpanOverloader @@ -9710,7 +9710,7 @@ public static unsafe int SetTextureUserData(this Sdl thisApi, Texture* textu } /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_render.h")] public static unsafe int UpdateTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pixels, int pitch) where T0 : unmanaged { // SpanOverloader @@ -9718,7 +9718,7 @@ public static unsafe int UpdateTexture(this Sdl thisApi, Texture* texture, [ } /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_render.h")] public static unsafe int UpdateTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pixels, int pitch) { // SpanOverloader @@ -9726,7 +9726,7 @@ public static unsafe int UpdateTexture(this Sdl thisApi, Texture* texture, [Flow } /// To be documented. - [NativeName("Src", "Line 597, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 598, Column 29 in SDL_render.h")] public static unsafe int UpdateTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pixels, int pitch) where T0 : unmanaged { // SpanOverloader @@ -9734,7 +9734,7 @@ public static unsafe int UpdateTexture(this Sdl thisApi, Texture* texture, [ } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9742,7 +9742,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -9750,7 +9750,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9758,7 +9758,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -9766,7 +9766,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9774,7 +9774,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -9782,7 +9782,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9790,7 +9790,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -9798,7 +9798,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -9806,7 +9806,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9814,7 +9814,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -9822,7 +9822,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -9830,7 +9830,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9838,7 +9838,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -9846,7 +9846,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9854,7 +9854,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -9862,7 +9862,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9870,7 +9870,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -9878,7 +9878,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9886,7 +9886,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -9894,7 +9894,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9902,7 +9902,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -9910,7 +9910,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -9918,7 +9918,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9926,7 +9926,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -9934,7 +9934,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -9942,7 +9942,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9950,7 +9950,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -9958,7 +9958,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -9966,7 +9966,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9974,7 +9974,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -9982,7 +9982,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -9990,7 +9990,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -9998,7 +9998,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -10006,7 +10006,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -10014,7 +10014,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -10022,7 +10022,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -10030,7 +10030,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -10038,7 +10038,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -10046,7 +10046,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -10054,7 +10054,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -10062,7 +10062,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -10070,7 +10070,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -10078,7 +10078,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Vplane, int Vpitch) { // SpanOverloader @@ -10086,7 +10086,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Vplane, int Vpitch) { // SpanOverloader @@ -10094,7 +10094,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 628, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 629, Column 29 in SDL_render.h")] public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Uplane, int Upitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Vplane, int Vpitch) { // SpanOverloader @@ -10102,7 +10102,7 @@ public static unsafe int UpdateYUVTexture(this Sdl thisApi, Texture* texture, [F } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan UVplane, int UVpitch) { // SpanOverloader @@ -10110,7 +10110,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* UVplane, int UVpitch) { // SpanOverloader @@ -10118,7 +10118,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan UVplane, int UVpitch) { // SpanOverloader @@ -10126,7 +10126,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string UVplane, int UVpitch) { // SpanOverloader @@ -10134,7 +10134,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan UVplane, int UVpitch) { // SpanOverloader @@ -10142,7 +10142,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* UVplane, int UVpitch) { // SpanOverloader @@ -10150,7 +10150,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan UVplane, int UVpitch) { // SpanOverloader @@ -10158,7 +10158,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string UVplane, int UVpitch) { // SpanOverloader @@ -10166,7 +10166,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* UVplane, int UVpitch) { // SpanOverloader @@ -10174,7 +10174,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan UVplane, int UVpitch) { // SpanOverloader @@ -10182,7 +10182,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string UVplane, int UVpitch) { // SpanOverloader @@ -10190,7 +10190,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* UVplane, int UVpitch) { // SpanOverloader @@ -10198,7 +10198,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan UVplane, int UVpitch) { // SpanOverloader @@ -10206,7 +10206,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 654, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 655, Column 29 in SDL_render.h")] public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string Yplane, int Ypitch, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string UVplane, int UVpitch) { // SpanOverloader @@ -10214,7 +10214,7 @@ public static unsafe int UpdateNVTexture(this Sdl thisApi, Texture* texture, [Fl } /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, void** pixels, Span pitch) { // SpanOverloader @@ -10222,7 +10222,7 @@ public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(S } /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, ref void* pixels, Span pitch) { // SpanOverloader @@ -10230,7 +10230,7 @@ public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(S } /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, void** pixels, int* pitch) { // SpanOverloader @@ -10238,7 +10238,7 @@ public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(S } /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, void** pixels, Span pitch) { // SpanOverloader @@ -10246,7 +10246,7 @@ public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(S } /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, ref void* pixels, int* pitch) { // SpanOverloader @@ -10254,7 +10254,7 @@ public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(S } /// To be documented. - [NativeName("Src", "Line 686, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 687, Column 29 in SDL_render.h")] public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, ref void* pixels, Span pitch) { // SpanOverloader @@ -10262,7 +10262,7 @@ public static unsafe int LockTexture(this Sdl thisApi, Texture* texture, [Flow(S } /// To be documented. - [NativeName("Src", "Line 722, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 723, Column 29 in SDL_render.h")] public static unsafe int LockTextureToSurface(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, Surface** surface) { // SpanOverloader @@ -10270,7 +10270,7 @@ public static unsafe int LockTextureToSurface(this Sdl thisApi, Texture* texture } /// To be documented. - [NativeName("Src", "Line 722, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 723, Column 29 in SDL_render.h")] public static unsafe int LockTextureToSurface(this Sdl thisApi, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, ref Surface* surface) { // SpanOverloader @@ -10278,7 +10278,7 @@ public static unsafe int LockTextureToSurface(this Sdl thisApi, Texture* texture } /// To be documented. - [NativeName("Src", "Line 844, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 848, Column 30 in SDL_render.h")] public static unsafe void RenderGetLogicalSize(this Sdl thisApi, Renderer* renderer, int* w, Span h) { // SpanOverloader @@ -10286,7 +10286,7 @@ public static unsafe void RenderGetLogicalSize(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 844, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 848, Column 30 in SDL_render.h")] public static unsafe void RenderGetLogicalSize(this Sdl thisApi, Renderer* renderer, Span w, int* h) { // SpanOverloader @@ -10294,7 +10294,7 @@ public static unsafe void RenderGetLogicalSize(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 844, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 848, Column 30 in SDL_render.h")] public static unsafe void RenderGetLogicalSize(this Sdl thisApi, Renderer* renderer, Span w, Span h) { // SpanOverloader @@ -10302,7 +10302,7 @@ public static unsafe void RenderGetLogicalSize(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 895, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 899, Column 29 in SDL_render.h")] public static unsafe int RenderSetViewport(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect) { // SpanOverloader @@ -10310,7 +10310,7 @@ public static unsafe int RenderSetViewport(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 908, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 912, Column 30 in SDL_render.h")] public static unsafe void RenderGetViewport(this Sdl thisApi, Renderer* renderer, Span> rect) { // SpanOverloader @@ -10318,7 +10318,7 @@ public static unsafe void RenderGetViewport(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 926, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 930, Column 29 in SDL_render.h")] public static unsafe int RenderSetClipRect(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect) { // SpanOverloader @@ -10326,7 +10326,7 @@ public static unsafe int RenderSetClipRect(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 942, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 946, Column 30 in SDL_render.h")] public static unsafe void RenderGetClipRect(this Sdl thisApi, Renderer* renderer, Span> rect) { // SpanOverloader @@ -10334,7 +10334,7 @@ public static unsafe void RenderGetClipRect(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 996, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1000, Column 30 in SDL_render.h")] public static unsafe void RenderGetScale(this Sdl thisApi, Renderer* renderer, float* scaleX, Span scaleY) { // SpanOverloader @@ -10342,7 +10342,7 @@ public static unsafe void RenderGetScale(this Sdl thisApi, Renderer* renderer, f } /// To be documented. - [NativeName("Src", "Line 996, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1000, Column 30 in SDL_render.h")] public static unsafe void RenderGetScale(this Sdl thisApi, Renderer* renderer, Span scaleX, float* scaleY) { // SpanOverloader @@ -10350,7 +10350,7 @@ public static unsafe void RenderGetScale(this Sdl thisApi, Renderer* renderer, S } /// To be documented. - [NativeName("Src", "Line 996, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1000, Column 30 in SDL_render.h")] public static unsafe void RenderGetScale(this Sdl thisApi, Renderer* renderer, Span scaleX, Span scaleY) { // SpanOverloader @@ -10358,7 +10358,7 @@ public static unsafe void RenderGetScale(this Sdl thisApi, Renderer* renderer, S } /// To be documented. - [NativeName("Src", "Line 1020, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1024, Column 30 in SDL_render.h")] public static unsafe void RenderWindowToLogical(this Sdl thisApi, Renderer* renderer, int windowX, int windowY, float* logicalX, Span logicalY) { // SpanOverloader @@ -10366,7 +10366,7 @@ public static unsafe void RenderWindowToLogical(this Sdl thisApi, Renderer* rend } /// To be documented. - [NativeName("Src", "Line 1020, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1024, Column 30 in SDL_render.h")] public static unsafe void RenderWindowToLogical(this Sdl thisApi, Renderer* renderer, int windowX, int windowY, Span logicalX, float* logicalY) { // SpanOverloader @@ -10374,7 +10374,7 @@ public static unsafe void RenderWindowToLogical(this Sdl thisApi, Renderer* rend } /// To be documented. - [NativeName("Src", "Line 1020, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1024, Column 30 in SDL_render.h")] public static unsafe void RenderWindowToLogical(this Sdl thisApi, Renderer* renderer, int windowX, int windowY, Span logicalX, Span logicalY) { // SpanOverloader @@ -10382,7 +10382,7 @@ public static unsafe void RenderWindowToLogical(this Sdl thisApi, Renderer* rend } /// To be documented. - [NativeName("Src", "Line 1046, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1050, Column 30 in SDL_render.h")] public static unsafe void RenderLogicalToWindow(this Sdl thisApi, Renderer* renderer, float logicalX, float logicalY, int* windowX, Span windowY) { // SpanOverloader @@ -10390,7 +10390,7 @@ public static unsafe void RenderLogicalToWindow(this Sdl thisApi, Renderer* rend } /// To be documented. - [NativeName("Src", "Line 1046, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1050, Column 30 in SDL_render.h")] public static unsafe void RenderLogicalToWindow(this Sdl thisApi, Renderer* renderer, float logicalX, float logicalY, Span windowX, int* windowY) { // SpanOverloader @@ -10398,7 +10398,7 @@ public static unsafe void RenderLogicalToWindow(this Sdl thisApi, Renderer* rend } /// To be documented. - [NativeName("Src", "Line 1046, Column 30 in SDL_render.h")] + [NativeName("Src", "Line 1050, Column 30 in SDL_render.h")] public static unsafe void RenderLogicalToWindow(this Sdl thisApi, Renderer* renderer, float logicalX, float logicalY, Span windowX, Span windowY) { // SpanOverloader @@ -10406,7 +10406,7 @@ public static unsafe void RenderLogicalToWindow(this Sdl thisApi, Renderer* rend } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, byte* g, byte* b, Span a) { // SpanOverloader @@ -10414,7 +10414,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, byte* g, Span b, byte* a) { // SpanOverloader @@ -10422,7 +10422,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, byte* g, Span b, Span a) { // SpanOverloader @@ -10430,7 +10430,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, byte* g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10438,7 +10438,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -10446,7 +10446,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, Span g, byte* b, byte* a) { // SpanOverloader @@ -10454,7 +10454,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, Span g, byte* b, Span a) { // SpanOverloader @@ -10462,7 +10462,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, Span g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10470,7 +10470,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, Span g, Span b, byte* a) { // SpanOverloader @@ -10478,7 +10478,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, Span g, Span b, Span a) { // SpanOverloader @@ -10486,7 +10486,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, Span g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10494,7 +10494,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -10502,7 +10502,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -10510,7 +10510,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10518,7 +10518,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, Span a) { // SpanOverloader @@ -10526,7 +10526,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, byte* a) { // SpanOverloader @@ -10534,7 +10534,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, Span a) { // SpanOverloader @@ -10542,7 +10542,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10550,7 +10550,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, byte* r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -10558,7 +10558,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, byte* g, byte* b, byte* a) { // SpanOverloader @@ -10566,7 +10566,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, byte* g, byte* b, Span a) { // SpanOverloader @@ -10574,7 +10574,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, byte* g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10582,7 +10582,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, byte* g, Span b, byte* a) { // SpanOverloader @@ -10590,7 +10590,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, byte* g, Span b, Span a) { // SpanOverloader @@ -10598,7 +10598,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, byte* g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10606,7 +10606,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -10614,7 +10614,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -10622,7 +10622,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10630,7 +10630,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, Span g, byte* b, byte* a) { // SpanOverloader @@ -10638,7 +10638,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, Span g, byte* b, Span a) { // SpanOverloader @@ -10646,7 +10646,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, Span g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10654,7 +10654,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, Span g, Span b, byte* a) { // SpanOverloader @@ -10662,7 +10662,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, Span g, Span b, Span a) { // SpanOverloader @@ -10670,7 +10670,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, Span g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10678,7 +10678,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -10686,7 +10686,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -10694,7 +10694,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10702,7 +10702,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, byte* a) { // SpanOverloader @@ -10710,7 +10710,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, Span a) { // SpanOverloader @@ -10718,7 +10718,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10726,7 +10726,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, byte* a) { // SpanOverloader @@ -10734,7 +10734,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, Span a) { // SpanOverloader @@ -10742,7 +10742,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10750,7 +10750,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -10758,7 +10758,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -10766,7 +10766,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, Span r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10774,7 +10774,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, byte* b, Span a) { // SpanOverloader @@ -10782,7 +10782,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b, byte* a) { // SpanOverloader @@ -10790,7 +10790,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b, Span a) { // SpanOverloader @@ -10798,7 +10798,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10806,7 +10806,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, byte* g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -10814,7 +10814,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b, byte* a) { // SpanOverloader @@ -10822,7 +10822,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b, Span a) { // SpanOverloader @@ -10830,7 +10830,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, byte* b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10838,7 +10838,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b, byte* a) { // SpanOverloader @@ -10846,7 +10846,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b, Span a) { // SpanOverloader @@ -10854,7 +10854,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10862,7 +10862,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, byte* a) { // SpanOverloader @@ -10870,7 +10870,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -10878,7 +10878,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, Span g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10886,7 +10886,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, byte* b, Span a) { // SpanOverloader @@ -10894,7 +10894,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, byte* a) { // SpanOverloader @@ -10902,7 +10902,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, Span a) { // SpanOverloader @@ -10910,7 +10910,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, Span b, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string a) { // SpanOverloader @@ -10918,7 +10918,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1102, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1106, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string r, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string g, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string b, Span a) { // SpanOverloader @@ -10926,7 +10926,7 @@ public static unsafe int GetRenderDrawColor(this Sdl thisApi, Renderer* renderer } /// To be documented. - [NativeName("Src", "Line 1143, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1147, Column 29 in SDL_render.h")] public static unsafe int GetRenderDrawBlendMode(this Sdl thisApi, Renderer* renderer, Span blendMode) { // SpanOverloader @@ -10934,7 +10934,7 @@ public static unsafe int GetRenderDrawBlendMode(this Sdl thisApi, Renderer* rend } /// To be documented. - [NativeName("Src", "Line 1213, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1217, Column 29 in SDL_render.h")] public static unsafe int RenderDrawPoints(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan points, int count) { // SpanOverloader @@ -10942,7 +10942,7 @@ public static unsafe int RenderDrawPoints(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1270, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1274, Column 29 in SDL_render.h")] public static unsafe int RenderDrawLines(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan points, int count) { // SpanOverloader @@ -10950,7 +10950,7 @@ public static unsafe int RenderDrawLines(this Sdl thisApi, Renderer* renderer, [ } /// To be documented. - [NativeName("Src", "Line 1296, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1300, Column 29 in SDL_render.h")] public static unsafe int RenderDrawRect(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect) { // SpanOverloader @@ -10958,7 +10958,7 @@ public static unsafe int RenderDrawRect(this Sdl thisApi, Renderer* renderer, [F } /// To be documented. - [NativeName("Src", "Line 1322, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1326, Column 29 in SDL_render.h")] public static unsafe int RenderDrawRects(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rects, int count) { // SpanOverloader @@ -10966,7 +10966,7 @@ public static unsafe int RenderDrawRects(this Sdl thisApi, Renderer* renderer, [ } /// To be documented. - [NativeName("Src", "Line 1352, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1356, Column 29 in SDL_render.h")] public static unsafe int RenderFillRect(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect) { // SpanOverloader @@ -10974,7 +10974,7 @@ public static unsafe int RenderFillRect(this Sdl thisApi, Renderer* renderer, [F } /// To be documented. - [NativeName("Src", "Line 1377, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1381, Column 29 in SDL_render.h")] public static unsafe int RenderFillRects(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rects, int count) { // SpanOverloader @@ -10982,7 +10982,7 @@ public static unsafe int RenderFillRects(this Sdl thisApi, Renderer* renderer, [ } /// To be documented. - [NativeName("Src", "Line 1409, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1414, Column 29 in SDL_render.h")] public static unsafe int RenderCopy(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -10990,7 +10990,7 @@ public static unsafe int RenderCopy(this Sdl thisApi, Renderer* renderer, Textur } /// To be documented. - [NativeName("Src", "Line 1409, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1414, Column 29 in SDL_render.h")] public static unsafe int RenderCopy(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect) { // SpanOverloader @@ -10998,7 +10998,7 @@ public static unsafe int RenderCopy(this Sdl thisApi, Renderer* renderer, Textur } /// To be documented. - [NativeName("Src", "Line 1409, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1414, Column 29 in SDL_render.h")] public static unsafe int RenderCopy(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect) { // SpanOverloader @@ -11006,7 +11006,7 @@ public static unsafe int RenderCopy(this Sdl thisApi, Renderer* renderer, Textur } /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan center, RendererFlip flip) { // SpanOverloader @@ -11014,7 +11014,7 @@ public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Text } /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Point* center, RendererFlip flip) { // SpanOverloader @@ -11022,7 +11022,7 @@ public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Text } /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan center, RendererFlip flip) { // SpanOverloader @@ -11030,7 +11030,7 @@ public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Text } /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Point* center, RendererFlip flip) { // SpanOverloader @@ -11038,7 +11038,7 @@ public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Text } /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan center, RendererFlip flip) { // SpanOverloader @@ -11046,7 +11046,7 @@ public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Text } /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Point* center, RendererFlip flip) { // SpanOverloader @@ -11054,7 +11054,7 @@ public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Text } /// To be documented. - [NativeName("Src", "Line 1453, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1459, Column 29 in SDL_render.h")] public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan center, RendererFlip flip) { // SpanOverloader @@ -11062,7 +11062,7 @@ public static unsafe int RenderCopyEx(this Sdl thisApi, Renderer* renderer, Text } /// To be documented. - [NativeName("Src", "Line 1485, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1491, Column 29 in SDL_render.h")] public static unsafe int RenderDrawPointsF(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan points, int count) { // SpanOverloader @@ -11070,7 +11070,7 @@ public static unsafe int RenderDrawPointsF(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1515, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1521, Column 29 in SDL_render.h")] public static unsafe int RenderDrawLinesF(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan points, int count) { // SpanOverloader @@ -11078,7 +11078,7 @@ public static unsafe int RenderDrawLinesF(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1529, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1535, Column 29 in SDL_render.h")] public static unsafe int RenderDrawRectF(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rect) { // SpanOverloader @@ -11086,7 +11086,7 @@ public static unsafe int RenderDrawRectF(this Sdl thisApi, Renderer* renderer, [ } /// To be documented. - [NativeName("Src", "Line 1543, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1549, Column 29 in SDL_render.h")] public static unsafe int RenderDrawRectsF(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rects, int count) { // SpanOverloader @@ -11094,7 +11094,7 @@ public static unsafe int RenderDrawRectsF(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1558, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1564, Column 29 in SDL_render.h")] public static unsafe int RenderFillRectF(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rect) { // SpanOverloader @@ -11102,7 +11102,7 @@ public static unsafe int RenderFillRectF(this Sdl thisApi, Renderer* renderer, [ } /// To be documented. - [NativeName("Src", "Line 1572, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1578, Column 29 in SDL_render.h")] public static unsafe int RenderFillRectsF(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rects, int count) { // SpanOverloader @@ -11110,7 +11110,7 @@ public static unsafe int RenderFillRectsF(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1590, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1596, Column 29 in SDL_render.h")] public static unsafe int RenderCopyF(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dstrect) { // SpanOverloader @@ -11118,7 +11118,7 @@ public static unsafe int RenderCopyF(this Sdl thisApi, Renderer* renderer, Textu } /// To be documented. - [NativeName("Src", "Line 1590, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1596, Column 29 in SDL_render.h")] public static unsafe int RenderCopyF(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* dstrect) { // SpanOverloader @@ -11126,7 +11126,7 @@ public static unsafe int RenderCopyF(this Sdl thisApi, Renderer* renderer, Textu } /// To be documented. - [NativeName("Src", "Line 1590, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1596, Column 29 in SDL_render.h")] public static unsafe int RenderCopyF(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dstrect) { // SpanOverloader @@ -11134,7 +11134,7 @@ public static unsafe int RenderCopyF(this Sdl thisApi, Renderer* renderer, Textu } /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan center, RendererFlip flip) { // SpanOverloader @@ -11142,7 +11142,7 @@ public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Tex } /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FPoint* center, RendererFlip flip) { // SpanOverloader @@ -11150,7 +11150,7 @@ public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Tex } /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan center, RendererFlip flip) { // SpanOverloader @@ -11158,7 +11158,7 @@ public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Tex } /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FPoint* center, RendererFlip flip) { // SpanOverloader @@ -11166,7 +11166,7 @@ public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Tex } /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FRect* dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan center, RendererFlip flip) { // SpanOverloader @@ -11174,7 +11174,7 @@ public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Tex } /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] FPoint* center, RendererFlip flip) { // SpanOverloader @@ -11182,7 +11182,7 @@ public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Tex } /// To be documented. - [NativeName("Src", "Line 1616, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1622, Column 29 in SDL_render.h")] public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> srcrect, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan dstrect, double angle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan center, RendererFlip flip) { // SpanOverloader @@ -11190,7 +11190,7 @@ public static unsafe int RenderCopyExF(this Sdl thisApi, Renderer* renderer, Tex } /// To be documented. - [NativeName("Src", "Line 1644, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1650, Column 29 in SDL_render.h")] public static unsafe int RenderGeometry(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Vertex* vertices, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan indices, int num_indices) { // SpanOverloader @@ -11198,7 +11198,7 @@ public static unsafe int RenderGeometry(this Sdl thisApi, Renderer* renderer, Te } /// To be documented. - [NativeName("Src", "Line 1644, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1650, Column 29 in SDL_render.h")] public static unsafe int RenderGeometry(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan vertices, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int* indices, int num_indices) { // SpanOverloader @@ -11206,7 +11206,7 @@ public static unsafe int RenderGeometry(this Sdl thisApi, Renderer* renderer, Te } /// To be documented. - [NativeName("Src", "Line 1644, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1650, Column 29 in SDL_render.h")] public static unsafe int RenderGeometry(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan vertices, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan indices, int num_indices) { // SpanOverloader @@ -11214,7 +11214,7 @@ public static unsafe int RenderGeometry(this Sdl thisApi, Renderer* renderer, Te } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan indices, int num_indices, int size_indices) where T0 : unmanaged { // SpanOverloader @@ -11222,7 +11222,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices) { // SpanOverloader @@ -11230,7 +11230,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan indices, int num_indices, int size_indices) where T0 : unmanaged { // SpanOverloader @@ -11238,7 +11238,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices) { // SpanOverloader @@ -11246,7 +11246,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan indices, int num_indices, int size_indices) where T0 : unmanaged { // SpanOverloader @@ -11254,7 +11254,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices) { // SpanOverloader @@ -11262,7 +11262,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan indices, int num_indices, int size_indices) where T0 : unmanaged { // SpanOverloader @@ -11270,7 +11270,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices) { // SpanOverloader @@ -11278,7 +11278,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan indices, int num_indices, int size_indices) where T0 : unmanaged { // SpanOverloader @@ -11286,7 +11286,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices) { // SpanOverloader @@ -11294,7 +11294,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Color* color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan indices, int num_indices, int size_indices) where T0 : unmanaged { // SpanOverloader @@ -11302,7 +11302,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices) { // SpanOverloader @@ -11310,7 +11310,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float* uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan indices, int num_indices, int size_indices) where T0 : unmanaged { // SpanOverloader @@ -11318,7 +11318,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* indices, int num_indices, int size_indices) { // SpanOverloader @@ -11326,7 +11326,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1674, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1680, Column 29 in SDL_render.h")] public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* renderer, Texture* texture, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan xy, int xy_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan color, int color_stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan uv, int uv_stride, int num_vertices, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan indices, int num_indices, int size_indices) where T0 : unmanaged { // SpanOverloader @@ -11334,7 +11334,7 @@ public static unsafe int RenderGeometryRaw(this Sdl thisApi, Renderer* rende } /// To be documented. - [NativeName("Src", "Line 1708, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1714, Column 29 in SDL_render.h")] public static unsafe int RenderReadPixels(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* rect, uint format, Span pixels, int pitch) where T0 : unmanaged { // SpanOverloader @@ -11342,7 +11342,7 @@ public static unsafe int RenderReadPixels(this Sdl thisApi, Renderer* render } /// To be documented. - [NativeName("Src", "Line 1708, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1714, Column 29 in SDL_render.h")] public static unsafe int RenderReadPixels(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, uint format, void* pixels, int pitch) { // SpanOverloader @@ -11350,7 +11350,7 @@ public static unsafe int RenderReadPixels(this Sdl thisApi, Renderer* renderer, } /// To be documented. - [NativeName("Src", "Line 1708, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1714, Column 29 in SDL_render.h")] public static unsafe int RenderReadPixels(this Sdl thisApi, Renderer* renderer, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> rect, uint format, Span pixels, int pitch) where T0 : unmanaged { // SpanOverloader @@ -11358,7 +11358,7 @@ public static unsafe int RenderReadPixels(this Sdl thisApi, Renderer* render } /// To be documented. - [NativeName("Src", "Line 1851, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1858, Column 29 in SDL_render.h")] public static unsafe int GLBindTexture(this Sdl thisApi, Texture* texture, float* texw, Span texh) { // SpanOverloader @@ -11366,7 +11366,7 @@ public static unsafe int GLBindTexture(this Sdl thisApi, Texture* texture, float } /// To be documented. - [NativeName("Src", "Line 1851, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1858, Column 29 in SDL_render.h")] public static unsafe int GLBindTexture(this Sdl thisApi, Texture* texture, Span texw, float* texh) { // SpanOverloader @@ -11374,7 +11374,7 @@ public static unsafe int GLBindTexture(this Sdl thisApi, Texture* texture, Span< } /// To be documented. - [NativeName("Src", "Line 1851, Column 29 in SDL_render.h")] + [NativeName("Src", "Line 1858, Column 29 in SDL_render.h")] public static unsafe int GLBindTexture(this Sdl thisApi, Texture* texture, Span texw, Span texh) { // SpanOverloader @@ -11466,7 +11466,7 @@ public static unsafe int IPhoneSetAnimationCallback(this Sdl thisApi, Window } /// To be documented. - [NativeName("Src", "Line 428, Column 34 in SDL_system.h")] + [NativeName("Src", "Line 432, Column 34 in SDL_system.h")] [ExcludeFromOverride(0)] public static unsafe SdlBool AndroidRequestPermission(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan permission) { @@ -11475,7 +11475,7 @@ public static unsafe SdlBool AndroidRequestPermission(this Sdl thisApi, [Flow(Si } /// To be documented. - [NativeName("Src", "Line 453, Column 29 in SDL_system.h")] + [NativeName("Src", "Line 457, Column 29 in SDL_system.h")] [ExcludeFromOverride(0)] public static unsafe int AndroidShowToast(this Sdl thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan message, int duration, int gravity, int xoffset, int yoffset) { @@ -11492,7 +11492,7 @@ public static unsafe int AddTimer(this Sdl thisApi, uint interval, PfnTimerC } /// To be documented. - [NativeName("Src", "Line 141, Column 30 in SDL_version.h")] + [NativeName("Src", "Line 142, Column 30 in SDL_version.h")] public static unsafe void GetVersion(this Sdl thisApi, Span ver) { // SpanOverloader diff --git a/src/Windowing/Silk.NET.SDL/Structs/AtomicT.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/AtomicT.gen.cs index 3463cadd62..668777d537 100644 --- a/src/Windowing/Silk.NET.SDL/Structs/AtomicT.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Structs/AtomicT.gen.cs @@ -16,7 +16,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousRecord_SDL_atomic_L263_C9")] [NativeName("Name", "SDL_atomic_t")] public unsafe partial struct AtomicT { diff --git a/src/Windowing/Silk.NET.SDL/Structs/DisplayMode.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/DisplayMode.gen.cs index 86014049a6..0113eaaf14 100644 --- a/src/Windowing/Silk.NET.SDL/Structs/DisplayMode.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Structs/DisplayMode.gen.cs @@ -16,7 +16,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousRecord_SDL_video_L53_C9")] [NativeName("Name", "SDL_DisplayMode")] public unsafe partial struct DisplayMode { diff --git a/src/Windowing/Silk.NET.SDL/Structs/GUID.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/GUID.gen.cs deleted file mode 100644 index 2d25fc6dd5..0000000000 --- a/src/Windowing/Silk.NET.SDL/Structs/GUID.gen.cs +++ /dev/null @@ -1,28 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using System.Runtime.InteropServices; -using System.Runtime.CompilerServices; -using System.Text; -using Silk.NET.Core; -using Silk.NET.Core.Native; -using Silk.NET.Core.Attributes; -using Silk.NET.Core.Contexts; -using Silk.NET.Core.Loader; - -#pragma warning disable 1591 - -namespace Silk.NET.SDL -{ - [NativeName("AnonymousName", "__AnonymousRecord_SDL_guid_L55_C9")] - [NativeName("Name", "SDL_GUID")] - public unsafe partial struct GUID - { - [NativeName("Type", "Uint8[16]")] - [NativeName("Type.Name", "Uint8[16]")] - [NativeName("Name", "data")] - public fixed byte Data[16]; - } -} diff --git a/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBind.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBind.gen.cs index 7ce2a681d1..4b792c3db1 100644 --- a/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBind.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBind.gen.cs @@ -42,8 +42,8 @@ public GameControllerButtonBind [NativeName("Name", "bindType")] public GameControllerBindType BindType; - [NativeName("Type", "union (unnamed union at build/submodules/SDL/include\\SDL_gamecontroller.h:94:5)")] - [NativeName("Type.Name", "union (unnamed union at build/submodules/SDL/include\\SDL_gamecontroller.h:94:5)")] + [NativeName("Type", "union (unnamed union at build/submodules/SDL/include\\SDL_gamecontroller.h:96:5)")] + [NativeName("Type.Name", "union (unnamed union at build/submodules/SDL/include\\SDL_gamecontroller.h:96:5)")] [NativeName("Name", "value")] public GameControllerButtonBindValue Value; } diff --git a/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBindValue.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBindValue.gen.cs index 1ba5e456fa..a659cbc808 100644 --- a/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBindValue.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBindValue.gen.cs @@ -17,7 +17,7 @@ namespace Silk.NET.SDL { [StructLayout(LayoutKind.Explicit)] - [NativeName("Name", "__AnonymousRecord_SDL_gamecontroller_L94_C5")] + [NativeName("Name", "__AnonymousRecord_SDL_gamecontroller_L96_C5")] public unsafe partial struct GameControllerButtonBindValue { public GameControllerButtonBindValue @@ -57,8 +57,8 @@ public GameControllerButtonBindValue public int Axis; [FieldOffset(0)] - [NativeName("Type", "struct (unnamed struct at build/submodules/SDL/include\\SDL_gamecontroller.h:98:9)")] - [NativeName("Type.Name", "struct (unnamed struct at build/submodules/SDL/include\\SDL_gamecontroller.h:98:9)")] + [NativeName("Type", "struct (unnamed struct at build/submodules/SDL/include\\SDL_gamecontroller.h:100:9)")] + [NativeName("Type.Name", "struct (unnamed struct at build/submodules/SDL/include\\SDL_gamecontroller.h:100:9)")] [NativeName("Name", "hat")] public GameControllerButtonBindValueHat Hat; } diff --git a/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBindValueHat.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBindValueHat.gen.cs index 80f00481a7..0da00e645c 100644 --- a/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBindValueHat.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Structs/GameControllerButtonBindValueHat.gen.cs @@ -16,7 +16,7 @@ namespace Silk.NET.SDL { - [NativeName("Name", "__AnonymousRecord_SDL_gamecontroller_L98_C9")] + [NativeName("Name", "__AnonymousRecord_SDL_gamecontroller_L100_C9")] public unsafe partial struct GameControllerButtonBindValueHat { public GameControllerButtonBindValueHat diff --git a/src/Windowing/Silk.NET.SDL/Structs/MessageBoxButtonData.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/MessageBoxButtonData.gen.cs index e2545fc129..e07466bb55 100644 --- a/src/Windowing/Silk.NET.SDL/Structs/MessageBoxButtonData.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Structs/MessageBoxButtonData.gen.cs @@ -16,7 +16,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousRecord_SDL_messagebox_L58_C9")] [NativeName("Name", "SDL_MessageBoxButtonData")] public unsafe partial struct MessageBoxButtonData { diff --git a/src/Windowing/Silk.NET.SDL/Structs/MessageBoxColor.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/MessageBoxColor.gen.cs index 8d11bcb1af..c8731e4356 100644 --- a/src/Windowing/Silk.NET.SDL/Structs/MessageBoxColor.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Structs/MessageBoxColor.gen.cs @@ -16,7 +16,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousRecord_SDL_messagebox_L68_C9")] [NativeName("Name", "SDL_MessageBoxColor")] public unsafe partial struct MessageBoxColor { diff --git a/src/Windowing/Silk.NET.SDL/Structs/MessageBoxColorScheme.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/MessageBoxColorScheme.gen.cs index 0587d0e66f..a6439b6e1a 100644 --- a/src/Windowing/Silk.NET.SDL/Structs/MessageBoxColorScheme.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Structs/MessageBoxColorScheme.gen.cs @@ -16,7 +16,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousRecord_SDL_messagebox_L86_C9")] [NativeName("Name", "SDL_MessageBoxColorScheme")] public unsafe partial struct MessageBoxColorScheme { diff --git a/src/Windowing/Silk.NET.SDL/Structs/MessageBoxData.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/MessageBoxData.gen.cs index 7aa72cd950..88b98a9a9b 100644 --- a/src/Windowing/Silk.NET.SDL/Structs/MessageBoxData.gen.cs +++ b/src/Windowing/Silk.NET.SDL/Structs/MessageBoxData.gen.cs @@ -16,7 +16,6 @@ namespace Silk.NET.SDL { - [NativeName("AnonymousName", "__AnonymousRecord_SDL_messagebox_L94_C9")] [NativeName("Name", "SDL_MessageBoxData")] public unsafe partial struct MessageBoxData { diff --git a/src/Windowing/Silk.NET.SDL/Structs/PfnCompareCallback.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/PfnCompareCallback.gen.cs new file mode 100644 index 0000000000..670a538647 --- /dev/null +++ b/src/Windowing/Silk.NET.SDL/Structs/PfnCompareCallback.gen.cs @@ -0,0 +1,53 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.SDL +{ + public unsafe readonly struct PfnCompareCallback : IDisposable + { + private readonly void* _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public PfnCompareCallback + ( + delegate* unmanaged[Cdecl] ptr + ) => _handle = ptr; + + public PfnCompareCallback + ( + CompareCallback proc + ) => _handle = (void*) SilkMarshal.DelegateToPtr(proc); + + public static PfnCompareCallback From(CompareCallback proc) => new PfnCompareCallback(proc); + public void Dispose() => SilkMarshal.Free((nint) _handle); + + public static implicit operator nint(PfnCompareCallback pfn) => (nint) pfn.Handle; + public static explicit operator PfnCompareCallback(nint pfn) + => new PfnCompareCallback((delegate* unmanaged[Cdecl]) pfn); + + public static implicit operator PfnCompareCallback(CompareCallback proc) + => new PfnCompareCallback(proc); + + public static explicit operator CompareCallback(PfnCompareCallback pfn) + => SilkMarshal.PtrToDelegate(pfn); + + public static implicit operator delegate* unmanaged[Cdecl](PfnCompareCallback pfn) => pfn.Handle; + public static implicit operator PfnCompareCallback(delegate* unmanaged[Cdecl] ptr) => new PfnCompareCallback(ptr); + } + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int CompareCallback(void* arg0, void* arg1); +} + diff --git a/src/Windowing/Silk.NET.SDL/Structs/PfnVvVvI.gen.cs b/src/Windowing/Silk.NET.SDL/Structs/PfnVvVvI.gen.cs deleted file mode 100644 index dfbeb6b8e4..0000000000 --- a/src/Windowing/Silk.NET.SDL/Structs/PfnVvVvI.gen.cs +++ /dev/null @@ -1,53 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using System.Runtime.InteropServices; -using System.Runtime.CompilerServices; -using System.Text; -using Silk.NET.Core; -using Silk.NET.Core.Native; -using Silk.NET.Core.Attributes; -using Silk.NET.Core.Contexts; -using Silk.NET.Core.Loader; - -#pragma warning disable 1591 - -namespace Silk.NET.SDL -{ - public unsafe readonly struct PfnVvVvI : IDisposable - { - private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; - public PfnVvVvI - ( - delegate* unmanaged[Cdecl] ptr - ) => _handle = ptr; - - public PfnVvVvI - ( - VvVvIProc proc - ) => _handle = (void*) SilkMarshal.DelegateToPtr(proc); - - public static PfnVvVvI From(VvVvIProc proc) => new PfnVvVvI(proc); - public void Dispose() => SilkMarshal.Free((nint) _handle); - - public static implicit operator nint(PfnVvVvI pfn) => (nint) pfn.Handle; - public static explicit operator PfnVvVvI(nint pfn) - => new PfnVvVvI((delegate* unmanaged[Cdecl]) pfn); - - public static implicit operator PfnVvVvI(VvVvIProc proc) - => new PfnVvVvI(proc); - - public static explicit operator VvVvIProc(PfnVvVvI pfn) - => SilkMarshal.PtrToDelegate(pfn); - - public static implicit operator delegate* unmanaged[Cdecl](PfnVvVvI pfn) => pfn.Handle; - public static implicit operator PfnVvVvI(delegate* unmanaged[Cdecl] ptr) => new PfnVvVvI(ptr); - } - - [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate int VvVvIProc(void* arg0, void* arg1); -} -

JwNXX2OOaaAEP;16SRN*w3>>3CnSh2R+~w2J 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 diff --git a/build/cache/shaderc.json.gz b/build/cache/shaderc.json.gz index b94a5b2f5cab6212341005fcc2f1d074368bf0d1..acc44364b025fa33f0e3fa850b399df0dce5fc10 100644 GIT binary patch literal 14181 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 J2NDM4{{Y|<+T#EK literal 14181 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 j2n)F-Vtx1JdSP>#rsIJki0I4MsjvB!^8*W5D@ zWLrrzC0iazP9-&%|9&?q$xlh9EXfwd)gQV$HYJmr(gne)^a954tsHEo-ke zYH($b{C?Fv&oPH{&tQG{=YRjQ=tk3VY^ODS(Jgb_o0-l_WQUsFZo8|s?jP#6tt+k9 zX>}iBI+xrsvZL1<|A_Z{Fm>m%neBMS&b|-sdxK7=-R(C;`k&NVWDHI5F|_Ai`|-}0 z*v?x*_uGTM*1p#6ns@E)_r$KpwG`?0Rq7>Ecb?`GW9kX4ntJzUaM!%=3oV?8#v%h~ zq#1yBr@tolyRY5V|J>2t%{Gy}{Iq*z|C4ouzrJg@b8AbW?(AixIpJ5Ni5^WW_-;D4 zti?wUhU1#{H2jolpiA8~`foF?u3FQv>5vYiCb!0mVbPD*s4tGAzg?L$k?dLjv*344 zKDTYhd@`rH75U+fW6x*d4~8E$ES;2F@ZpUyH5_xqI>ATF^yKAR*LZyY`=f5Tq$yi2 z?SqxSTGN$3`p>4j_MKOEJD#)n=z2coBkI`HF~jMZPgC8SGyUxUe9K+wKu33I5Y&u* z-f)a5)7<<$|0QX?dcFvPaYinpZB^c|XVH7NQSbBz-KKWezG`ZXb|-GX zv&Tl{Rvr1@YZJc#Hf)(T?7cnRnl-*`F6)gyn)g@Qefz!{v$A5EWZ0%RmTM*U=H|9{ zyQ4Q7O)~7iue*Blb$4&R3iReos5f^zI&-(PFL%4UaxT=B#w=QghCkHk#OciF7Li@K z5bDa`TtfJyzWlA%zTeTAjV6)3`H)p(hd-9Atm9i{*VC8!h<5)tQb!LL-$6Z>Nj(py zKc@E2=oQ{=_S%DPgSf}{PLu4kKkkWt#H_1bZ8PZX!PI=Toyq0=kp?Z)(bjdld#7Cv z$T;i@_BZB{49dOd*^d5X2zR^JZ+GiA%{1MPeIx@4^gQZxYdRwnL8Q;@=UexkL7b^6 z(mn%F@ZOR+lcu|5wWsUv)&m*fq&FYV$XXK?@Zhpj@AcA%IOd5ApcAa*)`b3*Vj;Kg z=-;W<@#Yheef}ucXMHlWjInT^>vx@7azLf%bIcRbFe=pNx@S+!QNx}yBoOFyz2ClT zk^R*k-1h}FM(iVz-To}p?athNZjdX((_?&7>s{y!dS9sn_q4ZS9aLgZME3cM*zz!D zgr%PNnr?RL-FiROqK4v{xyK$aw@uwpDe<`-Y$q!HcrY_sl z9{KG@oazXybn?PeFY5hP`<}E#chF!S2eB2u>(R*Jh&eaA`rF^h&l0ZZabE4P6I+H zFov63t#ey%-G>BEsQ(EMMf=5t`raqvZHvgg-@Na&#U#DeG@7o~vYM9bznW}d?rNKh z)83vtBj3*+-bmBGP8f;vCjDJb4#m!Q@f zW$+&{LG9|(K&Vq&tunZWNKhXyb_$9&*(Ip8Mj5<6Oi;V}G!W|4R;vuoo!#!g#m@?P z{&u&{;K{k}?Anq+i^QI7w8`L#x$f**`9X^v{n@?h#au4eom~qoXtAR|yBC+3>%{lA zCHKhpj_vBxR;vt7k$Cs(a@!|3Tw@z$@q_G)94sXv5H#4?IJ&EXmYweg7U|_qC9&Ns zx@TuOJ9?K|Dvgg<{Hf?soM+FrSi(|bxIGY+CnM%|Cr7VM4BIa?32~Px0pO#&0GX!MoaK*r5q_ zXT-0@vhZDPv!u2r>yVXS-K|9u8|R`&TGO%d8tW`(io|3s5Z)@Im)MWBKj@CB4=v-G zw7u@Nz2_K~&K6VV2)<{~F8MQ#_U>>=iMTc$Z~DpOT!IDIUub z1B)3-f?`eRRHBj2UJCUhl%L?VQ{?!!F+JaKeJ$?nB~2-_bntUggOH zDZqe-|5GAC;xn0HU}XeC7_inGK>$d6CbRb67{P9Bxz!yJU77q)o(oAxpOZNWe2ogMmaotIF7>YlYi>VO>zp++_%NuJiL2KSOc!zz$Q8ER|ihnW#9?<|g^cItKJ^dIu z-PT>J-+D;$*}5%tozt0 z3~0WR`Cb~f?TqgkDp}?)BRVIJuQ5N?Nf{CBgu*>T*xS}WnsF&|f{$cSX}sed^VNtx zfxq2>PV3KR+-dyXt&1rcviiFM`#iQ~K3m%ljdQ`qZ)(4hHVRsS$CPO|-y6DPxba^5 za0OjcIye32zFDV??j+Cs&IdB=;9GM_-4*TYZHxW5cvrXD7r%ppUl!lUu@B_ApRY|T zA~|krLqCSiu%o33vxe*FuGLxW(ByFI?k6&AXi@F6`s2bHDDj~Tds|Qot^B;OCQ5py zKqF%N*Tpqb;zN0Ar8{#bsF)_^49cmT$9ozU%~9X}hvC>emt+0viZ*ReYuwTYTEDIR zquFf>tjJx@WicWA?l;FVS*wZNXkNu8u%>w~gXRjle@R3cBPTl$VC$k+_5`mAf58~Jn z|3sd^Q6Gk!G)t_SxG;(O!^7xLUBJe0*yjVpv6 z`{TFq<WnyKG@ ztA9_eXttipaDG;hOsxIBIHTC{SiWBG$&9=g3>^i0-@L8%=r;zxC=5Ll(cFUUYa+B5y%b7PMIwLA5{51RXp zCFa=-%)}qYw`X%ZY%J83Z(mz|5vyC|+2TELYrPQHdOIG=Q|tM@gNAKwms#7=dPClp zl%L-iTCYr6kJU@E=Bx)77tx34*$N91<5(4^+W|lR>$i?uk-OSwP-rV1K8w$1jOYMw zoub2Q?K7yZ)ehHEb-0$Y!?nCTYhj0XsH^Qh?ABEx&*Y-0{QS!0SYp+bpIOQ4fh}4> zN0muOHEfq~f82aAqU&6-b=COVZQs?k+jhe*Pta)h2(_;?a^}RJKAzai6dk-w)xpbr{I2yB9jvG7U_H0G zgNaDEty6Ymp};fwpdtAhDFtlm^?sVaep&I^_M@<&<}O+S5zB;#-KXJBPz-%Q-y4^W zF25dfT(6pyYmU$pD+*N5hemb#VU2*@qYVo(yQq2YA{4RQr-`beDb2 ze@CXVZM`J}KnElHSUb%;GXEV}N4EZ!49Fgg?5vjHuMzE3@RF=!+jvd!Sv)Zv5_d)m zzaUSyG@m(kcP+u+^d-15dY6CtjXlIKv}Itp@)%ICOeom$=GXK?f-9GzY3yc){(xe@ zw<00>9gk(eIO_PlP6>cNQ+NHoPHBAK_UQc9gTWRiC%pXQ|ubr08j{o35wZ?K9A@fu5qLgL=B2Znw{Hr$89-7nf_8 zj*v#SkSYZ(oa&&_FGqux(enah%TGAi9 zDbPuxaxh7^8ZpOUi*12+hX=`$FE`rVIs<=rX-1nuYO^e-Iyec!x5t=+hql%NT6~ zTtZ(LHzWInirSZdYc~3#TTk#62?PBoJkaKpRVtzstPUmGF2F;4q|JL?fQh|;a%Q#W zpX|C>@l7cDj)bv(5*{n<#dL!Ue1B=ivi(Rx*FTF-Q!mAoq*`ZdtrPnCMO@5t>xVw= z851%d%~6V7^Dwymqkc~-|BkG{RwLCg5}r*MR6WH6Tp5o#f%3Iw>t4q(MkZTJU(KiI zS(>RKz`3pyq>|!pQ#xU%+ibMBfB9?c=4&V2#0kGEK?0ZQB|v_)9LCR_X8DXh`ArF9 z7rQi!Svo!paR0o}V7dJjC~h7}5FA?4bI~?CAIO#PK)8L;Gk+QU^iQ;59N8(Jrl<8< z|7iMWl;SMp)DI^NtC?3^A(|IHkG(e*u}dPQ=j z(B$Rd`kFqcKiFMn+PBtKKd#p2-Y-cQt>Bd^u2rAE`eWr6mIx2BKKL{29luK@#n2KS zO&E}1K@8fFezMU%gIc7a?KiL;kLNKs8jnfX?r|5ByU!Sz(~-cKAeqdUyWYNI6?{#? zn8nQ8MS<7$+?&n4y=FBq(D-Hcd(W-NOAC+sMd8dt=5>Pe8Mw%+5{CaV-SGQ{ z>t5?4&(1#WeO3wLy58usbC-EYLi~jZ^7xca9=urnH{1E~k#%wLfQOkz8E)#?S+wR`<$xAhNx2qwiKcRimlKrzFdWee*w#-RLd+_(LWEIh(S zy~Bx5u+LbfFTT}M3{v0~3FEv>$vOhU=!Z7NTq~>0AtZW!)Kb*JBKC%aQHmMb>~c(f zeC_B@EFR_0=pq?he5{@Nm3G~&-%!M&AI{1mc|FaLgwKkPIHI@gf_ZM&~0+$6Hk z^9hrEmTI!srnm0WZZxOCXDQtFe0J6+gG~?ZJ5n9N=jlQcDPNc{-@=BkF9V+rrnd!x zP6kA7FZM6+iiCL=EOAD2&Z<9OaT}k;B{s`^K3F|x&9}*EHHyyXjz{C8)Mvs5EzgvA zF^%XfuIXyJuIanak-F16=-KTGA5nXu^0J>3lYR)Qe^=wrW9wvn7Z{v8|I( z#bB=&B#cnl0&LkX*}fBF$k*q!K|8NEAI|icO1zOy^EP=7$z9$I7S?r>?Wo@1vQv+( z&YR^u3BwjP0ke)dkMSOAtgR`(8gA-cckc8Q5x>?wzv+(5p6d?bb*eyL(z6L;61Ibz zlQ|jjMq@stgr6BtQx)Hs#Hv_|TVrrZc{?3HwKUDX-0^(;_|9wT6wj40qMTypJq?oH z(<+~P3J3LCvVf4a^sgLU@?t421b?^0|_o*`Z5jDOQ{!HcL3 z==)TAH0=u$1ag*2ApU?;Bw#PQ>znTB60dhZoiH*nd)HsnJqmy6PeyA(|N8q}x6DV= zaITE;oS#Gxvkd)(*`ruhogIX{WB+CqqFdK3YIW7T8Z=S_4fc3lyajoFA)I8xr#TQu z=nNU?FG3>VDKP$gh5cT-EC%%l!J(&kO?>XmxtP(+hszjLYifF?e+_1Mzp3C61Kv@d z?bEt%^;`Zmmy7#Yh0hp>zb0XxKMKz?Wl{ZfOplF|rZ=F-b+_lFm}<&$`qpjr`9fvK z)k5A&)70yxnr-1XB}}-m74C0&7F_WIE6nGR7QGN`2}!Rrjym~G31hFP8+*et zXXK*b8IS{)-_ZQF2Qh1~12p7);2DbApht~J|9szzpb5PzK?0Y;n#>o$>BmdcVK{*)?4&55#R{PSj zM?X?TKYb1xoR%f>+M)!Y+jirRR1r^+m&8XoFV0fO%5L>HgWu~%lj)>E%|#qcyRCn3 z`Zx8_+;r37rPx~%=2tkb%guIU9C#JE-W47zH@vBDfiuw8m?=iN>-mK72`4Xi&(G$j zf1__`&sgTul(}w%$4T!Pw1NwJmsZGa>*k*MSW*mF_(cgL|B!0ri@}CDD=qP0hu_;p z_m;UO{2l4Wyz4Cq0~R-5!_ojcwRsJdF)iqHM=gC%LwLHs-tV^lTxwZH3DTaw-0Ow$ zT=C*liiimj|DHJ+bDkL1&`1|AA(l=_7k5{Fx-q+Vi+!CoTC)2s2`k`pN?$uEGd^JP zfrgH9(nP$6X@-~dY{H;~E!k`HmFs6dB$j|9?qhBJ>1$VC>MV68jgK|)>4cF9+o`@= zk*Df*gIWSOZ@K_zVeA!sM*@WuGhn-hrN7?m)5fzQ zN|L+H+xnjr%DC4WUz_5zIN`B)SMY_fZQ9j;h9@vtMnM`@*sXtCo}1(e0qI!buICfh z&HmbZ2bv;}k5im15|8!!b8zqu!;ETj@5icPLayYouOTu5-I;>JGZtzX1+t6_{4N9u7d;DX1C2!BL7C7l-qXwiu(cU zL=f&pZGyD#ir2{>&i6cv(5EoNJqd#rw{H!7%%YXynXhYB=udnXcboMq z7G7K)*}A5!k^@ z`6BGeA-6?y>N#)x3^M;**mJ`?4bbE8mBoW=U3Jtp3v;lPVDu&l=MT&=PKoixfHKS7__hjT%UV(rqkBEOmEgB*FrBz zSi+4x&(H^@!NeU>Tj$?{YF=p^Qv&Zu7^-;DES6mm`dCwK)b7IdnR16lKA5mdn^`YJ z*z8F1MF_iFXD=|#PJWw~;k0M5mtu~BCYl|#K~d==U3ozB<}3TPve6WjAwQrOGkN?w zjbXyZ`~BVt&*imgSYzIe&2BA45d8Vz4K4rwXn8SDW$^i6ZjP5yY0vb3vn5LdGFC4| z&>fc|#L@T0&-j;`=}0u7aEm2xF8Rjes|;5}XSfm#FE$CE56lU_m1sl_$9CPQR1!WS zkG_y;FhK-5PTTP>B^po9h#rb-$TSKu;w^XkR05kIyTJQY&g zEnlFy{KOY>lyCyGrS7_6&P@2)`Gj9-68u>okz#etp=q((K7X&V1$N+B<=Rl88D$%t zJ-0oxL;7Y#9NTle{0{S5+WC#1+pw&j@rZuG1>?|xHe+eSGvr>ma@ zGrA$1y=OFU`Vfq5n?D4HYXoV;&~Ggbo#>g?kCXdm|D@MxbstXnU};fpt?AzEW&68o zujrUlRly8zuIn`c0e(t5tK2IYjX^K$D@h4Pl(`edCL;|VHTH9y244}x_KZi$tF)lC zj4ejO6!p}3(`Lcme_MP6Xl*?Yj$PWht{TUt zXND#_e8(!01h@9aIq!Kx&15aZYtPHB!{Dl0TfK|f-XdPh>8+UWPDzg}+oBO}S-x{I z!SYXVps2T}I8e(4PjbZhPEqdt9#_C@<8RW&DQAfYBwa?M7b(KFXR z%z2>}q=%+4@IuMLnmW_z*BsxRPka5-5L`mhU@FTvm6578RIfQtWYOTkvf8`0y{MWJ zol^Krtu%+4EhtZpd0#-1qU|$Jced@7wGZV$60n1%mw)>}v$66K=2J3y5K~NkxbZRO zRkC^Q&Ge`gq16v1GdCGy@XPuvex}PVe26CwFTAy;hs`N+?zablkYf?w2BlLrr`X#3 zye#SoNt&YSDdsS%yZO0ff#gMv+QqL#s;5bWc7k4#23)1nOE7N)XLfN9>*mz59qT)^ zF}V^?ZnQU)O>VSD6gyX<$?cJ992-%S>#lzz$K*zz>G4BrwyjQLX@^x&j4tFlV@V#H z->pW<13{H-Y8M4E!%MHOZD*p#r=Sk`8JA%yMujuKVbCLbrAN_Eod z048C04-GB+NAkeYrjNA>UEY+GTF{mytHCmqMqyRVG6YTmr*I;-95@B%PvIwWjS)+n z**cB8@v&ravq=7NmWqIAtT}>apdeCEkYEKbPI?C?#xqDsHA%^# zlsUVVEQKm})|*$``5DM&BinoBvt3F&Xk2Dy8kRzdNkd!=Ev$K>EfW(<%|}r+L_9}4 z;`rFwhoveJf=mj*iM=x1QA7dXF@4Mm_(}#`I01l+@ru(8q&`)9a)V3UqS9l$jjy1S z<(uA^s#V-B*!W652lj@Ua3*Xgl;3j=O97UG+65W zvcWV~Kimp}ZV0Muk%Z-xUsLu4U!uF_{Bg5kwI}_~oGwJOuFcHpQWnXxzi5W(mu~v? zr&>gZ5Y|Psd1cS4 zJa!p{YmLjhCN9Z%Wh=w7Mfl;6x2DmpH?Q`ZSQpXyk%x78B(I5$#${U*kCq*E+G+FS zYR~npJ*KftX5<>!K3PB3M(jJH`&)-xLMdTV%RH(2Yr>?id|C2Ijl69_r9=*z$okZD zZO^f1Z`lXRe87-7&cR&8FEOCAJbS1mp-L zI|QE{d!k222uJ+8DujytQLfY!jMD|dkXNb&C^#$6ISGdQM8H zb5@NhUU6g1qS_Ud@@=XKdv4vbQbZpuq_(AumV(*IPGW^v^5qgddp_~ZHiJ+Va3J+G$ zZmLu{kwhLHWi{_&(rVbwjp55yxM$^~RbzRVz_21Ju_6Zg){2;~e1sLDoQ~)@TPwm{ z`3NgQy%iBtHzc|;O0nosv~}BgoHiZDb{e{64fWBFNYmC}Ews_H$&qc^&{bcD{XW2Ghe*^Gi8ffM`v2|ay{=x&$^@5Jf23(<7r9ev9{+cYhq6c+@fcteb;H-HoIE8(`WNSf8Wu6E?fPz$vLg@ zf3RZ;nW7uAZ$&5Q=C*gcH9cpTo&tB!*A&z9HEMb;Fg*oM&z<<}+(k^zXG~6klXFWs zk=(EnnV#GF{SBL+-r59RV}c5tpyo8Nd_^Xxc|W*|m>~WSxIs?yL;9>Ucb`LZJtor5 z=ZERD&Y<^|ChES|uiy7+a_+BM_cvhHMNLh8{(3ooqy|0DnUB2C`5rer^}(Oo<>307 z_E4|i9W?r(1+-4Dv3YWuA;#52cMs=kS+-B;U<*HV?3F5rWD}F8?LQRbF`XA}#JR`1ZzFSzNxO6Ru*>wXhjudonz2d0t02mbUnjwV9a&F2KDbFuMw(OsNjAJc0vJyU>1kODOx?n-i0@ecSGad*dFoM8{?Dz`D^%9T$%zul{)3;wSPa`j-&nM{T~F# z{C`+Pi!`V4%KvJ)T|*zYr`Fr5$|9BRm}6u4(ex!a4NmfWG++H+U0KKg%?tzzpb5|f zJINC?Yo(!qWUR`?0)d&Em`OGTFtc3t3@}p}LldeTc4pZZG%ypGS$ZEJFtel+1I#R? zoMC1HG7ssRg_&78&3t^wg!O}PraaUH;Y?sAFjMX0qQFdvgFi?CDkEls1i~{5GZT;r zGgEfRgeHfTS#}PHU?x1XurlG91!T&e$_XPAh*`NB2c0GME z6FIJl3XQ@p+YuME<^+<~^yyghR%E?j@bkFr^2_o_))xhiWX125UiP!iE~~ouq+mf) zY?syTvRrU}`On|q4W<))sy`WHzO**>1qQNhJ$4)93zw{>hoaR?U$z<3bJ+W`oXy^z^Mt!VH^)#> z-C2GQ)cN@rh0bk5FBL=yj;fbxGUz4g+$m5?2eb3pMcU8$*l=jd4d+oG84o)BKNwR^ zn#twDC4Ce~S9{T&oU{|YDI;mxp7{j*6g3iXr(qsV0MJ0%?+8GaZ&R z!L}<Qu%|g2PfLD5xqZsG1}S3Is}i{Zt@hX$;vz6OAKPrIb{GM*(b>{T+$;@Jb1stx( zX?u)9(Q2+Q+ngLB!P_$08k-ZJ0OeZ)ftU73>gmJB(-J~C)RTSlS4hh(2!p{ z6`3>Wuea}`;fMi2z4@ zDwaM7tyOWYRg+L_fojRGw2GoyUoGV86r--5ty1R_MofH+l8PJ%IMuNVte&b=JPqop zvg)ZOhk62el3zO&MV{#A$vf&b97E?7{xU|uX}!-aFJ_rLn_pHr1U~WwOUovZY<9bj zy)RiIoh43AFxN4&6Z`;J(UDlur;nc%syh$8QzgA~S|+^%x+A~ZDVXkD8I+D@zoC3b zZt7;dkfksyI#|AYEGE4v1nDnotr14dwOI?gph#x+_B7o4l)oNKv5M#C(b z7M;iG=EjQh{B11|2^@f-g#2#c9@u@=#hN2}U*ELuJk_!|reADxyuCKrrz%I?|FSCI z(=75GzD36zrOTrBYa44lETJ(G!*m zER_SL55rQCKnuW9fu&M$OC{Om)~^-q$S6Y^FY80$R?2_YWXek$Il39xBlGD*pXyJ> z*f%mNYR(j#?n~l!jUF2(PB`Un(ae~1HNK1xbdkxF38!pte`|ETTi@T>o4vFYa%-O^ z$oZ%3jA^&9XEGq}G+NrO`ODB0&SqbVnd_mkW;$8UNOGtcx8f=aE`CFum0dc2?1g%% zav(589+d=vkxKo5z<|K0Okhq+MqtX|r~!Y014h{rGvF`P;X%q05^3M_Y3*txMFL1wrzErTfZ^NFD1lPWR;xRL?D0<`@SA{`>ohO@NVMWjFL0TNii!Ya$D3`Yp8Jmy}=P zDv?s>d9g@*`Fmr17G&RN~Sanjud>QkiuOnZ|nmN{n zft)jYB@d>PDmh^iq<4JzxKv3Wt8du)i*4PqZO?MLqXV}gZt0~B3s6V2Fcj^@2-arL@GfoJ zf~`;hA_V)ImrNb{Le6L;98EW=>&@5%hD^CAYqA#;JtY78`xo7sXG#K!F0Ak8w)q=V z(bauaU)|^0nSvJC5_ku`Ums4oB7rvutpIpsQ%wNg3IMO7flV2(SFJL1J~FhXuBTfT z0%gU!Lrq`Qh?L2xoJ!yi1u`578PvMVJIJ8${|j@hh{)JNw#bo?N%On*+@Z%aq)6<( z&{E+7>&NB)r)5mtg_bY*!iJVtQp;z(wpiUNj!^Ok&uplV$6x7vhQojkguVb(uaC#t zGZ(RD`7#Evmr3OZlZJchtEcc)^y)+57tQUV@T;!yYZ)0n2tM>Z2)qNW1RR~?PTqVliSXqfBm^f!yrly zyW#MTqOS4pIqi#uX#-zT0Z`)jLe`8GDZ^VN6PVDEm*uQGbUt)G%Jmhk^Wij7&1v*O&FZiB^GSdx<3&$%sJ1wbJ}l{)zYI;u`mfXZ zB(x;POaBpSEgpT|BskuBx>5%ALKWWz>835kB%+tHruV9-oVFDc9NUulI843|GcaED z5L*V#uj295D9zu?PDzzD>7e|jn=&Z>Qbiov zfR@h++7%DMx@);t#>{(e^Ex>?O>kz@LdBB23F?2j!Ch_4M6KC=;T&JsfPwO>C%}LT zFmP5|!oVk0VBk)7fAl;ucSwuQ=HBJoZSWjSfda5#Lekb;CT`8<^45lLnzfWTz(6K2 zSeZDKQ7%-{Yy;U-QkM{QC6QOf+ak7*_i}Dpo(bSR81N1k0tfEOguBam+Z%Qlp8sB_ z)qObOTaU)R<+bR|Uberhj@v>8Y*4Z8(O1j0dKCD#ZI60HdW*z!tG|)zf>~AoIy{rO z`ISNr37kF-B(7PZ$bk=XSquIIYUcFO&T_z+ZNs%a7?&@@mlIz_>nlj*6VR*k!I~o* zuUf!-zTz$gFawwY%!zm3r~(8z0duVaz+BF{<-p}?8_cD|<)Y7SGKEkdj~@)jGhP=m z>>3k&28+2Ui<#99e&G_=^ibrQ6UZDUvrNbw&RQl@IcE3m0Osfw1j~6bEjun~#6dRs zAo^TUpEe-+aCxVIXyqWfRy~L=yA2J5uBH)vuBZ{sHNyRT^38UBJh46P=9ZSE@FA#O zFwM0HuZr|@A$O!Fm1Xv1&{xZ%Naq)-Wyu)+MW>haqvrJK+R~qLsM$tuom+AG%Gvx< zu{4=L;@Z#`IXmLaWe%rb`4!c2ABD441fuh`vbj8}w_9X@hR^Ccn>L^Us8FPzX%iKI z2eReWFXk;<#^lzf+m)KJv2aw5{Tvr7E>3|Jz={LJB!CqvU`4GWSW(U(1fb$59&+|d ze+>>?gSo3wE-812Fx}-wpZijVYe^<}nAl^(%JG11^VJy5+0%Eyi?`3|#x_xQ63A7H zdKnTBp=dYioEkn&jWN0Gsu^jJz;}9au3||r&T({?1Zn=_4_uipi_U}Wm^?y^~_&TO+~Aw;F1@9Q6Oj&98IF?>660h zDJXyoORiYe6c)aPF$edzpjP^#uvY5m-sl;s=^(0U#$*izh4@^`_}s^u!V0Q2B{=Ut zJM?aTV)V|Kzz<%SiZYqBHE$_yZNlY^5FJ8vJCxL^no4TB*bmNM6~v;VD)B)#NfEAF zZXGsrZkEGWwCA=rTzoz~TR5AG21l=sm1_1;$vd!s5(lc?0F+P%C2EyG2^_kT1SC!m z0um_Ya5#{_>0HS{B8N&2cj*r2vZaGM4rMvF^6`VR#sqKzII(r(5-wya?C_#2I017) z5|}uOIdO*2!~yLIjfoq9Q{^p+v(!+bogqSTG^65E3DM#xMg`CUXaT$8&~`;>(E_H0 zBw%qE)1vpRj}3=sXTqu|(5i5`oc+X1*b|aPD8gCG5}yb+8g=MV9~lq2vlAf}YbJPx z-8=+~;#d~Nr<$@B1wi63p=^LewLzj*C6It2Aqhqt+>n6B=};hn*hCd!Vh>y5Y%iQZ zfZ}*rPoK(|9eZ$d0#E^{K*G~OEs9b@1&j(wkm8U=gM-CzHl|lbCXP)i!_=VP8gP6f|?|soV+_@ET-!f<2&gPd& znHb|h;@Ws2a?QU)9EY`KGBw!r1rvu$$t!m$`KK>x+7G1tL&^AeMO_&$=ExwVAg%58 zX2fuS4h5kDDHBZ(gdg5KNmrI1pwTj>}Y7R;Q%cno}Khmth>)@5Qv@K#i~8qSw8mSR4Zw*s{2NNx+zB6&R+phciXRZC8R zv*@ss0ajFEXVLf3aD)VlLo=ecK!*Nk4L@#H9wAV}4%E~KP!@UF! zYqk4guT^cyv}o`k(qE3|P+B>Cue?JE)ae+`Bv2~Lc?iY_?*C;l<{rA z@6){jRqmu?xLnn|MFTEZ5Z8(=X(U-5-LnUe zYZ*2PJgy+Fe)!xm+_~jd^42gA*NRLeh-*nD4Ua2`D{@?MtQx#kF^6l<@U9*GiS@kA z@2O|s*;AfUfmHJeMFH&}=r)%;{)saCMraDi^ol3v>+xU9GUSsyuF z?}M7@dN+nwpL_O%nvc4MYtNmLk=xZvir&q=1B0IkgY{76%y-6xj$4S~DV5rbDMl=TmZh(hlzyn!uOZmfC15n_G`%(bKXElMMJ|17aP4$U6x|~0f zri0_IAXL!DV{Pn9S{sI(;-TXrZu%l1cRyh zXgiZjin06vttpV!m|Wc2+?TgD33#V=GTJys<&xpH^XY{N)xUKMLfS_m@DFDKO zvr+&EY5_v6{D6Rh*plGEVGawxKmZ=Bs3_bbazH$A>CHSN7$(A2-Ghag2h)i@)t`(p z7xMq+vV8iBHB()}A=I?F{c`;~V z8P20VG9Glt)Q1+$5+aBBt3iG?g$tarb^?iOFDoKP;7}^RfWZ#nCJ=?QM4~`GxtJ?l z>BSZ02<5MX_~rCeK}rlHI4mIs5~zg)rzJ-M#0n(=f}(x6v=p0DMn}i62@Zk;EOEr} zB@UwiP>=`(FbR%i5~!F~-f#@vGkVYZn5i_sj0W67ML@uaOImZes23$m;180`3Rs=F zy}d%KTP+F(7C)knhp23kh|_bx0pOr8ivVz-6datE4GuzIkTfC(8XVkB6lok>+m0Vj zMilu7_@F)7P8eNAOj#}s1{>m-GWR!4VF4Uf%(T)4^2?Zme-y7BfcYSy900TA8VuH4 zsYDK31}@8zkc?&jse%HAxzw1io9-J zV~+Jw%v+Wn!i5>^w10X@iM$$yd0so~Sq7*qaBHH+m*5J)?(EfbN>s-B1x$z*yY!s!$EOi_GB zb3*}x)|6ixf!2W5R2Xd2(wgMZyK`jasZQu5Z^EQ=^=!*+}lA5%`&o;bPf4Eoof38h)o2yE#nY$@=NAw4HYhBWnM ziU<}+5fXC{KdHW_;X=*$39vJN?*gzB4h1B&!bz`+lfI153A3}D(LF$C^+K@l#g{z3 z4NtIYo?t~G`OcUO4F`udi-P9~moLt40;{(Q&$9|+T1AgCr-bZamzZ49;SeDX%vOB8 zvzhln;4vm9XRzCO*hb4IBhA%B-$cWN{S0WN#HFp_!<*{b~$(qF; zb*N^trqX;B2M`PMec~LVgdh%gC)}OYqNRx9R@vKjq3C@YU@rwnZoyt8)b(I5U@t1N z7u1&qd4cN%*P4R7NUZ8XUO-+zUQj$l@px1zJvv3lqXtuQJ)m$%5k8$c6D?|nfEVGu zcO>nUhV~yBV^zGalVdDObQO)XDAFan&l!#gI3lX$h(Kzxk}T(3L6-AXck}ckMBh!z zaervrmTDB|S$E+|DA81vfZ6nLLlr<)VOPS(CCGkK2xRkjBmio+pccM_(vhPQATH`M zqAnwR2^BK9WS}{p6r?#f;umzD?m=xv)XIA|de)tHzp3U(c)~@UC7GlW5E{i@2uIfJ zUzVEvi(;C+m)&Yr_Hs8UcL^p5%Kg~Fl|Z>K)uY38;qUKq&8I#vbet6r9eH{^qZtvU z64A0W#_!g@RR%rQ5*9j+{Yc-eu7%*E2ihupJp`Yw?w`fPtyEpy+kguvKgJn{!j3Qy zkjNvaCXxWfKdc-H`lyhJwofr-IO4LPEpF+MNh<+#0lEO)qCodlO~2?S=)y;O04o=` z3*1FC45wB~K`SM|UAU}MqI&-6x^P@aK{_&a<#g~NWA~6U4t9yj&6wQNi7FpF!|7is zX5h#?>RipB!T$F!B6N`6g@Jp%D*_TYs07*r+OthD7ujyTPOJNHvSvYVr?E$Vtr+n< zGVS@GX4od0_8@puSnvkSM`|qv<^zXMwQv{Z-i|#35-=YG&i3L}I0jxgk-~+85+V(} zM(`R{fjb=;xj(7wv%o?8LXT1cUS(58fLFLCs^yxH0A67jrv&fj)N|hW@^P~#lXeYv zZpD?lbT+?K2D@oZJ8#-76fz1SlwZ{?_sYiPCG3r}#J#cHXmM4h_`+HFxp%)QdnM@V z1Wf0X%^kFN_SZC~6tDTq&`92@h`Vgi{_$K*%NgJc@I@6OfNxd6w^j!5^_)4dS90tv z`l51RFAQH)0L;tqJ(be%4RN9x&ls<#ho76#whO0ej`dUYNabIZI*o z_Eufa2=^8c?seD0y@>Wo2E0M~I?78F3a=A;Y*;xS=Wf0lqd9x}E_m_wk?z-;VNkpHf#ST}gBX0e z8vI=#Zy0aOl8q9^MPq78ul$4(d8QybC4gT<#K3c^u2zuxgNT^4D;y3Tsiq4&r<`sE z1jKMi3}sfppO8_6>#UGE4gQ2YmvWr_#@RDCpx}T~@9Y^;vSsmTzySpZ6cU9?TRaB= zJOuC%zyp86*?sUQBq~W6z{5c+$@vo|5GUnS%-2L>)iEynZCHjrb&c_|gk<0c>>4!H zQxwa~&A;_zc-knC_G&H35HNxSa^#ekSV!SHB%J3093P;>;isB{B@ScZxR?D#LS?NA zAhN782ShGm>ND<2Qq({eLgeK-aX4K4{w`Nf+kx?(zJmEJ6=VSH0rsd{1FSEzj;adQ zS1rjC);9ndHCBqVzEMaH#y0>N#y5;_c-j&Bmd_-?{m8fCMi})l>Jd^$l3Nwj6o4K;51_9&&?8cxCN|JByfqS=Js?*UIobot&IT3~ zg#~jaU7&%Cx(H~XI2xQQhz6T>!8g-;UdjnZLV-qt_LF3-=_|s<0a~C0YzA?hroB_k zVztc))V8fNqHqLr#`xX(w<=5d6jDBbl+PgLO7hAJ1$pJo2CvM4OLh%+Zbj&8&a<4& zFO@kGwoWQRBV}|puvtsk7iT&8p8awOn;z(Qzg4q#LfUJw=99%P+PiSnG@4er<}X9@ zDw;Vf0}OvG;gK-Furx~?FkC^E1Q?bWhHGVjVb7V%wd8@q$2gb`V;CqL6Nd#yQYk?>!RVC7m?P&cj?f!E!7m# zv+izaBPb)uZ06;>I7D#Nw?ow9;=J=@Wr@~nc^^WW$TFG~6`4HTP#BO3-Q zRc}5i6k=e~{HjmKmQX3ot8A3s9@tJOb&z$qd+R(^*DdW^N?>sziKWNY zJzqX7ozOLfbWgCRGisidH%0n;w!cM0HFDV^&1v{XH(s;C~*`(}>4XJpJ3 zpmj`7`xyuqY6og3PVK0az#FKY2O>2#p~dI14mm#1JDYlEv=A-m4s=em&N;2sYU(MS`}t&3lR*FEZg8=K@H!K-HeQu8lo6Cs ztTH-POc|}Kp_Y4V(l*m`IHiF!!-X!|&_SB%YSu!`&_*TJM$5gjm_3}$t6+))DgHC{ zavavRcTo(Kk~Vn~g;Ej54V4c)Uv9S>^t>{9ekFJLTpe%2oiQ02j;~SSX(+_gFySKR zpTWyea(#bnC3K;fmw}YfQUf8OHh%@QqI|$L%dLA*>qiNmsbJpn#@Wn#%lzPEXoC6= z4&rK~K=g1bmlyz!t(lgW8lJ0S0kQN-Fh;j_MY>*^s6d8b7|6Cz;gb2*>CrJifbh?s+c%hOmYPna&ERXYE$oGj*Ka}Y+ z4#W$S4B97F`<$wme8RO4*C$2}B{raaBD9abkS>%DluxYkIa5^m+|4b|4Ez<)K!uoJ zlXVe84M7dXsv(t%O0HXAL1+s)s3;q3S*I2n2pT9>16?Spfdc(=Z95a)%iSlz4Uw8cyzNYWw}$sw%#XLh4HA zLeT!bA_XWcD6Ck8wUTc1QK8EMt_(`XbBuA%bLJy2pVDSs!zG7GOfgqy^Gjv!3>XKZ zCMLyXol~K+@Fy}=mR`OiYRXoAqI#2-`Ysthcc|rkn6n4L9@%?kPh*PO(`z;F-EZoy z=p!exoUKH2z5s3kw}4x~E#S8Na9b+_+!6-^+RBc$r^hgEyR;o>Lg z+&iEN%6-USI3Upp%K0IYK|(A*1_P=mDn)IOC?X}dStgPz?8*VRIk*!C+(uq7 z0Jj0RQHtBZZ3Ai}huelN;#E%5etdL|98UA%%*ht3;RoW@*^C`Z8;4G00s!zC@Rx!vBatKLa&B7VE9&c8k6%{o(0zpT-H>SC znBP9;A}OZ;rZZ$>*Tzilntw~Q!)`%j4Y=t28^@UJk(?tFLYU+HO<=xqUUbLQhnAt4 zW85)wJTv&Sf@Uxv;wbmK0V33dh+3&20xA6!K!}4F5o=aMU`)VxC=MCcO@+{kfXN^S z9vnNK^F_@Xcu-P@EPw|URSn9zf-MQe^=#LL&|CCio5+snDeqmlk|OZ!-EYd=u$y$7 z({w&rMSRq#tr$LE)PT=0B7o14AhAX?R6zsab2af9byfk-a(MY*J|8gp1M^umcs{L; z`5Xp~CbBB zhykY$Yexg8D`H3kr^{+h3(gG8X}~nhX}G%q(^d9&=VG+UW=_lC^M*BD;S*P-w5H+p zmM^*qYg&!4G+&tKYL&82lHiw=ZO{(mpKfoS&a66!ZLMJ3shJ>zTid!UCWQFa8~%@RQ`PJ+aYh zF3kX9qE$hQ*F!j2lijP8+)pW|;SJMJhH3bPX;7D1T`Z~91*jFM6{uD8Ip58)Ca8J> zY6WTqhMS36)g&@BP;r(o4atU}hi|h%74{4MZ#u`Rj05Re@Lm(aXTAKyN{;K&(KlK&(KlK&(Kl za3Bp1tMca?B624p6oe zROetv@<4Se0KuR-pgNV{nR!qhTu=d~BTcO*FdZ-*lyCymDI25A?o%kQQ%8n7GvU*z zYWS*@J{>R}sVpb>bgE(Q!l!e5IfLnxpXtD*1EN!QqT^SKCznodq+7akJv;rFJwNBs zvh|2Ggw2nu&1`}j^jNgY<+9Ztec@)#$64G5fD2&{aq%}Zdh*Z7nN!23sWB#7s+xNu zEuovQ!mm5UdcT7ESIOof#ygW{0_Q$H>-^+GvJ9pqu8D(dJGgVi}K)#FbU zP_>kDhVQqssQPJ%svng@)m9#;8VRauW2p%&J^oYyOG_zdU}b8XnER{~jBQFV9Dmh^}GM0X>DQ%&C zhJjja2$cyKc}eA0L%>wnrBn6TJNpnKdGexb_ z`7pGma=3ft#a_EVBKlKxEYo$_!Z?)+QfcN)Z_af_hKoR=vkF#nX4;xBF_M_09k-+#TXGlwoIbW2(l6S(&lb+3h~eC_r%wqbm)O_*Un*w} zqnzRKrwYkVrIa&@MN}4Cmqqu_6-*n>16-rA6_85l!+=ykDk?<)Qq{6oSE}xRQV3Ex zfEHAGiCb+Ry^|tJD%z-Q=*SyB_9RK6eU|mf&ugk^pI*NAQsV4FsC!)8N?9(PfP<`* za)yKK078DztvQ3h{kf(4Y&%I;Pi%f)9eybTb@_5y!d#jIQkOicz=OI(QWq40mqZ1j zkO8PmW$-jd>hfsWdIWRX{1}AgpoHa2ZNidA^b~|8lCU6hDxHo;U10cHKv)#MH(LrH z%el&wC70`K!B`>~3$Cq|MFD}Zz{64*G|e+Oq~@*UQjnGll}Sr3w*!N;M35HT4=jrU z0%-whsSKLtNLrM-vp@=}@N2M!YRHiF~&j<_^ z<7Q!kg_i|n1?MbKP)i@5&$@%y&~Z4+X|1L*XK8`66y#w6XMuwSXG2j0 zw_2P9jOFM-q0^dL^=~IL(=wbJ!@Hz)=)AQb9|>l!ZRg4u*$#g+yW1sZu`_TV+P0+( zkMU*AuM!z@X=^qYxAtf|+IUsqncXq|PbF)p)5J*&mqyIQt^7n=bu{3&;S_P#&WrAt z`p~NEeLE@TytYO5mUqvzew^Gl`zO6ltNU=Wrsy^%p*MSp{94%=_-Q-iKxt*sExW6{ zy!%aEaUYuieNyV?G!P&VAP^uBpz`7Y2#|yXs8$*R|c z2LKCX_0|Ck4u4d~r%b!TE~hz!UEqg49{R3ak^=OFAqMnC5FY3&4f^Jh^Z+L)!1sVo zP%?Tc-GlPWjd4St>D=@-X#-?Vfa@CW+=^T8&gPfOB*BdXVQZsxX(RhhCbM^A@)9=5 zS(?18#SVPi-Z%V6$UDl;S~hz3n=%HGzO&2UxtPRts@%7D;1)@ zsN$9eHUpcHnGS4L2AgYTz-HtQRREe{HcQ6&VK!I9Qp?9|K9$~V4q>Dk$PBAl%49A; zGd$XWW}N2+G*=gzVKf7or8Alr-9)6haFf|sl{MnbG8xQkQX6_q#)Vku$wi`rpi!0zG9VZg4mermw(q0L=UiNn|h>cZGXS~XC&deLD~3^%zq>Reld_-OA@=0d-4?x-fMCy3&Ad*O=(DnK2F>&6k!v`VkP7 zod=0eGZK0gq1OonzVtT_naH)NFLQ)>Wx`-wrcq%#?Cea{QccvI?<>4lQHJ1bK_?g$D$gxW1RTiIazz+DUw`hA z)DMq2X9u{?hF6#6NVB}e3MrP(HoxS{Z1OA{m2{oo;{5Bf z5z0m_e6hmwfplLfN!GcVrZ;HNL4C2HL9n=SsqtQS`hfo@D;h{_y|gAnuz^%wlRV21rAAAhyZ7%3t&U0RRC1 O{{sNG+2SVBCkg<=M_oh! literal 21241 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 Q0RR6304|Wfd?f4%07J2=VgLXD diff --git a/build/cache/spirv-reflect.json.gz b/build/cache/spirv-reflect.json.gz index 3e35dc4ae50597f347f2e60562b8da24ed8d7d40..cf87619daff07f95d36e49489acb5f7d52b9ae33 100644 GIT binary patch delta 22321 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 z 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 S0|2K6CplZ81^}}anh#ueC*Riq delta 39767 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≥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�fnkD@f0NhTci!~f6TyEeCtWBJ2h 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

eR^?3);+S+Wyt+hFz41bt+!Si}KCB^;Tn&HOv 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 M0GQ!MS5B3P0Q0NS2mk;8 delta 228576 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 z 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 diff --git a/build/cache/openxr.json.gz b/build/cache/openxr.json.gz index 5e1b7a610ecf6711b432b2fcf22378736a3b66ef..fad44e760a786991c4d9df834fb69e8dce976b12 100644 GIT binary patch literal 248647 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 z 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 {?#9p2`2I$7y44L^n%5ke%z`c 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 bxwlLJMuQ&<3+wzG7mG&@qekN7h=uh(CbgvK literal 248647 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≈|swxZ)Ak)`WkVbWt%l#{goP1;Yc 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 Wli!BBc^ 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

h1UO{XW4p7eXo@YBGql0YrC}6X@Ks`XPqJAPP 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