react-native-wgpu 0.5.10 → 0.5.11

package/cpp/webgpu/webgpu_cpp.h

@@ -54,6 +54,7 @@ static constexpr uint32_t kArrayLayerCountUndefined = WGPU_ARRAY_LAYER_COUNT_UND
 static constexpr uint32_t kCopyStrideUndefined = WGPU_COPY_STRIDE_UNDEFINED;
 static constexpr float kDepthClearValueUndefined = std::numeric_limits<float>::quiet_NaN();
 static constexpr uint32_t kDepthSliceUndefined = WGPU_DEPTH_SLICE_UNDEFINED;
+static constexpr uint32_t kInvalidBinding = WGPU_INVALID_BINDING;
 static constexpr uint32_t kLimitU32Undefined = WGPU_LIMIT_U32_UNDEFINED;
 static constexpr uint64_t kLimitU64Undefined = WGPU_LIMIT_U64_UNDEFINED;
 static constexpr uint32_t kMipLevelCountUndefined = WGPU_MIP_LEVEL_COUNT_UNDEFINED;
@@ -240,13 +241,6 @@ enum class DeviceLostReason : uint32_t {
 static_assert(sizeof(DeviceLostReason) == sizeof(WGPUDeviceLostReason), "sizeof mismatch for DeviceLostReason");
 static_assert(alignof(DeviceLostReason) == alignof(WGPUDeviceLostReason), "alignof mismatch for DeviceLostReason");
 
-enum class DynamicBindingKind : uint32_t {
-    Undefined = WGPUDynamicBindingKind_Undefined,
-    SampledTexture = WGPUDynamicBindingKind_SampledTexture,
-};
-static_assert(sizeof(DynamicBindingKind) == sizeof(WGPUDynamicBindingKind), "sizeof mismatch for DynamicBindingKind");
-static_assert(alignof(DynamicBindingKind) == alignof(WGPUDynamicBindingKind), "alignof mismatch for DynamicBindingKind");
-
 enum class ErrorFilter : uint32_t {
     Validation = WGPUErrorFilter_Validation,
     OutOfMemory = WGPUErrorFilter_OutOfMemory,
@@ -304,6 +298,7 @@ enum class FeatureName : uint32_t {
     TextureFormatsTier1 = WGPUFeatureName_TextureFormatsTier1,
     TextureFormatsTier2 = WGPUFeatureName_TextureFormatsTier2,
     PrimitiveIndex = WGPUFeatureName_PrimitiveIndex,
+    TextureComponentSwizzle = WGPUFeatureName_TextureComponentSwizzle,
     DawnInternalUsages = WGPUFeatureName_DawnInternalUsages,
     DawnMultiPlanarFormats = WGPUFeatureName_DawnMultiPlanarFormats,
     DawnNative = WGPUFeatureName_DawnNative,
@@ -316,7 +311,6 @@ enum class FeatureName : uint32_t {
     PixelLocalStorageCoherent = WGPUFeatureName_PixelLocalStorageCoherent,
     PixelLocalStorageNonCoherent = WGPUFeatureName_PixelLocalStorageNonCoherent,
     Unorm16TextureFormats = WGPUFeatureName_Unorm16TextureFormats,
-    Snorm16TextureFormats = WGPUFeatureName_Snorm16TextureFormats,
     MultiPlanarFormatExtendedUsages = WGPUFeatureName_MultiPlanarFormatExtendedUsages,
     MultiPlanarFormatP010 = WGPUFeatureName_MultiPlanarFormatP010,
     HostMappedPointer = WGPUFeatureName_HostMappedPointer,
@@ -327,10 +321,8 @@ enum class FeatureName : uint32_t {
     AdapterPropertiesMemoryHeaps = WGPUFeatureName_AdapterPropertiesMemoryHeaps,
     AdapterPropertiesD3D = WGPUFeatureName_AdapterPropertiesD3D,
     AdapterPropertiesVk = WGPUFeatureName_AdapterPropertiesVk,
-    R8UnormStorage = WGPUFeatureName_R8UnormStorage,
     DawnFormatCapabilities = WGPUFeatureName_DawnFormatCapabilities,
     DawnDrmFormatCapabilities = WGPUFeatureName_DawnDrmFormatCapabilities,
-    Norm16TextureFormats = WGPUFeatureName_Norm16TextureFormats,
     MultiPlanarFormatNv16 = WGPUFeatureName_MultiPlanarFormatNv16,
     MultiPlanarFormatNv24 = WGPUFeatureName_MultiPlanarFormatNv24,
     MultiPlanarFormatP210 = WGPUFeatureName_MultiPlanarFormatP210,
@@ -361,9 +353,16 @@ enum class FeatureName : uint32_t {
     ChromiumExperimentalSubgroupMatrix = WGPUFeatureName_ChromiumExperimentalSubgroupMatrix,
     SharedFenceEGLSync = WGPUFeatureName_SharedFenceEGLSync,
     DawnDeviceAllocatorControl = WGPUFeatureName_DawnDeviceAllocatorControl,
-    TextureComponentSwizzle = WGPUFeatureName_TextureComponentSwizzle,
-    ChromiumExperimentalBindless = WGPUFeatureName_ChromiumExperimentalBindless,
     AdapterPropertiesWGPU = WGPUFeatureName_AdapterPropertiesWGPU,
+    SharedBufferMemoryD3D12SharedMemoryFileMappingHandle = WGPUFeatureName_SharedBufferMemoryD3D12SharedMemoryFileMappingHandle,
+    SharedTextureMemoryD3D12Resource = WGPUFeatureName_SharedTextureMemoryD3D12Resource,
+    ChromiumExperimentalSamplingResourceTable = WGPUFeatureName_ChromiumExperimentalSamplingResourceTable,
+    ChromiumExperimentalSubgroupSizeControl = WGPUFeatureName_ChromiumExperimentalSubgroupSizeControl,
+    AtomicVec2uMinMax = WGPUFeatureName_AtomicVec2uMinMax,
+    Unorm16FormatsForExternalTexture = WGPUFeatureName_Unorm16FormatsForExternalTexture,
+    OpaqueYCbCrAndroidForExternalTexture = WGPUFeatureName_OpaqueYCbCrAndroidForExternalTexture,
+    Unorm16Filterable = WGPUFeatureName_Unorm16Filterable,
+    RenderPassRenderArea = WGPUFeatureName_RenderPassRenderArea,
 };
 static_assert(sizeof(FeatureName) == sizeof(WGPUFeatureName), "sizeof mismatch for FeatureName");
 static_assert(alignof(FeatureName) == alignof(WGPUFeatureName), "alignof mismatch for FeatureName");
@@ -583,12 +582,13 @@ enum class SType : uint32_t {
     SurfaceSourceXCBWindow = WGPUSType_SurfaceSourceXCBWindow,
     SurfaceColorManagement = WGPUSType_SurfaceColorManagement,
     RequestAdapterWebXROptions = WGPUSType_RequestAdapterWebXROptions,
+    TextureComponentSwizzleDescriptor = WGPUSType_TextureComponentSwizzleDescriptor,
+    ExternalTextureBindingLayout = WGPUSType_ExternalTextureBindingLayout,
+    ExternalTextureBindingEntry = WGPUSType_ExternalTextureBindingEntry,
     CompatibilityModeLimits = WGPUSType_CompatibilityModeLimits,
-    TextureBindingViewDimensionDescriptor = WGPUSType_TextureBindingViewDimensionDescriptor,
+    TextureBindingViewDimension = WGPUSType_TextureBindingViewDimension,
     EmscriptenSurfaceSourceCanvasHTMLSelector = WGPUSType_EmscriptenSurfaceSourceCanvasHTMLSelector,
     SurfaceDescriptorFromWindowsCoreWindow = WGPUSType_SurfaceDescriptorFromWindowsCoreWindow,
-    ExternalTextureBindingEntry = WGPUSType_ExternalTextureBindingEntry,
-    ExternalTextureBindingLayout = WGPUSType_ExternalTextureBindingLayout,
     SurfaceDescriptorFromWindowsUWPSwapChainPanel = WGPUSType_SurfaceDescriptorFromWindowsUWPSwapChainPanel,
     DawnTextureInternalUsageDescriptor = WGPUSType_DawnTextureInternalUsageDescriptor,
     DawnEncoderInternalUsageDescriptor = WGPUSType_DawnEncoderInternalUsageDescriptor,
@@ -601,7 +601,7 @@ enum class SType : uint32_t {
     RequestAdapterOptionsLUID = WGPUSType_RequestAdapterOptionsLUID,
     RequestAdapterOptionsGetGLProc = WGPUSType_RequestAdapterOptionsGetGLProc,
     RequestAdapterOptionsD3D11Device = WGPUSType_RequestAdapterOptionsD3D11Device,
-    DawnRenderPassColorAttachmentRenderToSingleSampled = WGPUSType_DawnRenderPassColorAttachmentRenderToSingleSampled,
+    DawnRenderPassSampleCount = WGPUSType_DawnRenderPassSampleCount,
     RenderPassPixelLocalStorage = WGPUSType_RenderPassPixelLocalStorage,
     PipelineLayoutPixelLocalStorage = WGPUSType_PipelineLayoutPixelLocalStorage,
     BufferHostMappedPointer = WGPUSType_BufferHostMappedPointer,
@@ -613,7 +613,7 @@ enum class SType : uint32_t {
     DawnDrmFormatCapabilities = WGPUSType_DawnDrmFormatCapabilities,
     ShaderModuleCompilationOptions = WGPUSType_ShaderModuleCompilationOptions,
     ColorTargetStateExpandResolveTextureDawn = WGPUSType_ColorTargetStateExpandResolveTextureDawn,
-    RenderPassDescriptorExpandResolveRect = WGPUSType_RenderPassDescriptorExpandResolveRect,
+    RenderPassRenderAreaRect = WGPUSType_RenderPassRenderAreaRect,
     SharedTextureMemoryVkDedicatedAllocationDescriptor = WGPUSType_SharedTextureMemoryVkDedicatedAllocationDescriptor,
     SharedTextureMemoryAHardwareBufferDescriptor = WGPUSType_SharedTextureMemoryAHardwareBufferDescriptor,
     SharedTextureMemoryDmaBufDescriptor = WGPUSType_SharedTextureMemoryDmaBufDescriptor,
@@ -656,16 +656,17 @@ enum class SType : uint32_t {
     RenderPassDescriptorResolveRect = WGPUSType_RenderPassDescriptorResolveRect,
     RequestAdapterWebGPUBackendOptions = WGPUSType_RequestAdapterWebGPUBackendOptions,
     DawnFakeDeviceInitializeErrorForTesting = WGPUSType_DawnFakeDeviceInitializeErrorForTesting,
-    TextureComponentSwizzleDescriptor = WGPUSType_TextureComponentSwizzleDescriptor,
     SharedTextureMemoryD3D11BeginState = WGPUSType_SharedTextureMemoryD3D11BeginState,
     DawnConsumeAdapterDescriptor = WGPUSType_DawnConsumeAdapterDescriptor,
-    BindGroupLayoutDynamicBindingArray = WGPUSType_BindGroupLayoutDynamicBindingArray,
-    DynamicBindingArrayLimits = WGPUSType_DynamicBindingArrayLimits,
-    BindGroupDynamicBindingArray = WGPUSType_BindGroupDynamicBindingArray,
     TexelBufferBindingEntry = WGPUSType_TexelBufferBindingEntry,
     TexelBufferBindingLayout = WGPUSType_TexelBufferBindingLayout,
     SharedTextureMemoryMetalEndAccessState = WGPUSType_SharedTextureMemoryMetalEndAccessState,
     AdapterPropertiesWGPU = WGPUSType_AdapterPropertiesWGPU,
+    SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor = WGPUSType_SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor,
+    SharedTextureMemoryD3D12ResourceDescriptor = WGPUSType_SharedTextureMemoryD3D12ResourceDescriptor,
+    RequestAdapterOptionsAngleVirtualizationGroup = WGPUSType_RequestAdapterOptionsAngleVirtualizationGroup,
+    PipelineLayoutResourceTable = WGPUSType_PipelineLayoutResourceTable,
+    AdapterPropertiesExplicitComputeSubgroupSizeConfigs = WGPUSType_AdapterPropertiesExplicitComputeSubgroupSizeConfigs,
 };
 static_assert(sizeof(SType) == sizeof(WGPUSType), "sizeof mismatch for SType");
 static_assert(alignof(SType) == alignof(WGPUSType), "alignof mismatch for SType");
@@ -831,7 +832,7 @@ enum class TextureFormat : uint32_t {
     R8BG8Biplanar444Unorm = WGPUTextureFormat_R8BG8Biplanar444Unorm,
     R10X6BG10X6Biplanar422Unorm = WGPUTextureFormat_R10X6BG10X6Biplanar422Unorm,
     R10X6BG10X6Biplanar444Unorm = WGPUTextureFormat_R10X6BG10X6Biplanar444Unorm,
-    External = WGPUTextureFormat_External,
+    OpaqueYCbCrAndroid = WGPUTextureFormat_OpaqueYCbCrAndroid,
 };
 static_assert(sizeof(TextureFormat) == sizeof(WGPUTextureFormat), "sizeof mismatch for TextureFormat");
 static_assert(alignof(TextureFormat) == alignof(WGPUTextureFormat), "alignof mismatch for TextureFormat");
@@ -934,14 +935,25 @@ enum class WGSLLanguageFeatureName : uint32_t {
     Packed4x8IntegerDotProduct = WGPUWGSLLanguageFeatureName_Packed4x8IntegerDotProduct,
     UnrestrictedPointerParameters = WGPUWGSLLanguageFeatureName_UnrestrictedPointerParameters,
     PointerCompositeAccess = WGPUWGSLLanguageFeatureName_PointerCompositeAccess,
-    SizedBindingArray = WGPUWGSLLanguageFeatureName_SizedBindingArray,
-    TexelBuffers = WGPUWGSLLanguageFeatureName_TexelBuffers,
-    ChromiumPrint = WGPUWGSLLanguageFeatureName_ChromiumPrint,
+    UniformBufferStandardLayout = WGPUWGSLLanguageFeatureName_UniformBufferStandardLayout,
+    SubgroupId = WGPUWGSLLanguageFeatureName_SubgroupId,
+    TextureAndSamplerLet = WGPUWGSLLanguageFeatureName_TextureAndSamplerLet,
+    SubgroupUniformity = WGPUWGSLLanguageFeatureName_SubgroupUniformity,
+    TextureFormatsTier1 = WGPUWGSLLanguageFeatureName_TextureFormatsTier1,
     ChromiumTestingUnimplemented = WGPUWGSLLanguageFeatureName_ChromiumTestingUnimplemented,
     ChromiumTestingUnsafeExperimental = WGPUWGSLLanguageFeatureName_ChromiumTestingUnsafeExperimental,
     ChromiumTestingExperimental = WGPUWGSLLanguageFeatureName_ChromiumTestingExperimental,
     ChromiumTestingShippedWithKillswitch = WGPUWGSLLanguageFeatureName_ChromiumTestingShippedWithKillswitch,
     ChromiumTestingShipped = WGPUWGSLLanguageFeatureName_ChromiumTestingShipped,
+    SizedBindingArray = WGPUWGSLLanguageFeatureName_SizedBindingArray,
+    TexelBuffers = WGPUWGSLLanguageFeatureName_TexelBuffers,
+    ChromiumPrint = WGPUWGSLLanguageFeatureName_ChromiumPrint,
+    FragmentDepth = WGPUWGSLLanguageFeatureName_FragmentDepth,
+    ImmediateAddressSpace = WGPUWGSLLanguageFeatureName_ImmediateAddressSpace,
+    BufferView = WGPUWGSLLanguageFeatureName_BufferView,
+    FilteringParameters = WGPUWGSLLanguageFeatureName_FilteringParameters,
+    SwizzleAssignment = WGPUWGSLLanguageFeatureName_SwizzleAssignment,
+    LinearIndexing = WGPUWGSLLanguageFeatureName_LinearIndexing,
 };
 static_assert(sizeof(WGSLLanguageFeatureName) == sizeof(WGPUWGSLLanguageFeatureName), "sizeof mismatch for WGSLLanguageFeatureName");
 static_assert(alignof(WGSLLanguageFeatureName) == alignof(WGPUWGSLLanguageFeatureName), "alignof mismatch for WGSLLanguageFeatureName");
@@ -1198,7 +1210,6 @@ class BindGroupLayout;
 class Buffer;
 class CommandBuffer;
 class CommandEncoder;
-class ComputePassEncoder;
 class ComputePipeline;
 class Device;
 class ExternalTexture;
@@ -1207,9 +1218,8 @@ class PipelineLayout;
 class QuerySet;
 class Queue;
 class RenderBundle;
-class RenderBundleEncoder;
-class RenderPassEncoder;
 class RenderPipeline;
+class ResourceTable;
 class Sampler;
 class ShaderModule;
 class SharedBufferMemory;
@@ -1219,12 +1229,16 @@ class Surface;
 class TexelBufferView;
 class Texture;
 class TextureView;
+class ComputePassEncoder;
+class RenderBundleEncoder;
+class RenderPassEncoder;
 
 struct StringView;
 struct AdapterPropertiesD3D;
+struct AdapterPropertiesExplicitComputeSubgroupSizeConfigs;
 struct AdapterPropertiesVk;
 struct AdapterPropertiesWGPU;
-struct BindGroupDynamicBindingArray;
+struct BindingResource;
 struct BlendComponent;
 struct BufferBindingLayout;
 struct BufferHostMappedPointer;
@@ -1246,15 +1260,13 @@ struct DawnFakeBufferOOMForTesting;
 struct DawnFakeDeviceInitializeErrorForTesting;
 struct DawnHostMappedPointerLimits;
 struct DawnInjectedInvalidSType;
-struct DawnRenderPassColorAttachmentRenderToSingleSampled;
+struct DawnRenderPassSampleCount;
 struct DawnShaderModuleSPIRVOptionsDescriptor;
 struct DawnTexelCopyBufferRowAlignmentLimits;
 struct DawnTextureInternalUsageDescriptor;
 struct DawnTogglesDescriptor;
 struct DawnWGSLBlocklist;
 struct DawnWireWGSLControl;
-struct DynamicBindingArrayLayout;
-struct DynamicBindingArrayLimits;
 struct EmscriptenSurfaceSourceCanvasHTMLSelector;
 struct Extent2D;
 struct Extent3D;
@@ -1268,6 +1280,7 @@ struct MultisampleState;
 struct Origin2D;
 struct Origin3D;
 struct PassTimestampWrites;
+struct PipelineLayoutResourceTable;
 struct PipelineLayoutStorageAttachment;
 struct PrimitiveState;
 struct QuerySetDescriptor;
@@ -1275,17 +1288,17 @@ struct QueueDescriptor;
 struct RenderBundleDescriptor;
 struct RenderBundleEncoderDescriptor;
 struct RenderPassDepthStencilAttachment;
-struct RenderPassDescriptorExpandResolveRect;
 struct RenderPassDescriptorResolveRect;
 struct RenderPassMaxDrawCount;
 struct RequestAdapterWebGPUBackendOptions;
 struct RequestAdapterWebXROptions;
+struct ResourceTableDescriptor;
 struct SamplerBindingLayout;
 struct ShaderModuleCompilationOptions;
 struct ShaderSourceSPIRV;
 struct ShaderSourceWGSL;
 struct SharedBufferMemoryBeginAccessDescriptor;
-struct SharedBufferMemoryDescriptor;
+struct SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor;
 struct SharedBufferMemoryEndAccessState;
 struct SharedBufferMemoryProperties;
 struct SharedFenceDXGISharedHandleDescriptor;
@@ -1337,7 +1350,7 @@ struct TexelBufferBindingLayout;
 struct TexelBufferViewDescriptor;
 struct TexelCopyBufferLayout;
 struct TextureBindingLayout;
-struct TextureBindingViewDimensionDescriptor;
+struct TextureBindingViewDimension;
 struct TextureComponentSwizzle;
 struct VertexAttribute;
 struct YCbCrVkDescriptor;
@@ -1345,7 +1358,6 @@ struct AdapterPropertiesMemoryHeaps;
 struct AdapterPropertiesSubgroupMatrixConfigs;
 struct AHardwareBufferProperties;
 struct BindGroupEntry;
-struct BindGroupLayoutDynamicBindingArray;
 struct BindGroupLayoutEntry;
 struct BlendState;
 struct BufferDescriptor;
@@ -1362,10 +1374,12 @@ struct InstanceDescriptor;
 struct Limits;
 struct PipelineLayoutPixelLocalStorage;
 struct RenderPassColorAttachment;
+struct RenderPassRenderAreaRect;
 struct RenderPassStorageAttachment;
 struct RequestAdapterOptions;
 struct SamplerDescriptor;
 struct ShaderModuleDescriptor;
+struct SharedBufferMemoryDescriptor;
 struct SharedFenceDescriptor;
 struct SharedFenceExportInfo;
 struct SharedTextureMemoryAHardwareBufferProperties;
@@ -1594,7 +1608,6 @@ class BindGroup : public ObjectBase<BindGroup, WGPUBindGroup> {
     using ObjectBase::ObjectBase;
     using ObjectBase::operator=;
 
-    inline void Destroy() const;
     inline void SetLabel(StringView label) const;
 
 
@@ -1695,30 +1708,6 @@ class CommandEncoder : public ObjectBase<CommandEncoder, WGPUCommandEncoder> {
     static inline void WGPURelease(WGPUCommandEncoder handle);
 };
 
-class ComputePassEncoder : public ObjectBase<ComputePassEncoder, WGPUComputePassEncoder> {
-  public:
-    using ObjectBase::ObjectBase;
-    using ObjectBase::operator=;
-
-    inline void DispatchWorkgroups(uint32_t workgroupCountX, uint32_t workgroupCountY = 1, uint32_t workgroupCountZ = 1) const;
-    inline void DispatchWorkgroupsIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const;
-    inline void End() const;
-    inline void InsertDebugMarker(StringView markerLabel) const;
-    inline void PopDebugGroup() const;
-    inline void PushDebugGroup(StringView groupLabel) const;
-    inline void SetBindGroup(uint32_t groupIndex, BindGroup const& group = nullptr, size_t dynamicOffsetCount = 0, uint32_t const * dynamicOffsets = nullptr) const;
-    inline void SetImmediateData(uint32_t offset, void const * data, size_t size) const;
-    inline void SetLabel(StringView label) const;
-    inline void SetPipeline(ComputePipeline const& pipeline) const;
-    inline void WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const;
-
-
-  private:
-    friend ObjectBase<ComputePassEncoder, WGPUComputePassEncoder>;
-    static inline void WGPUAddRef(WGPUComputePassEncoder handle);
-    static inline void WGPURelease(WGPUComputePassEncoder handle);
-};
-
 class ComputePipeline : public ObjectBase<ComputePipeline, WGPUComputePipeline> {
   public:
     using ObjectBase::ObjectBase;
@@ -1773,6 +1762,7 @@ class Device : public ObjectBase<Device, WGPUDevice> {
               typename CbChar = std::function<void(CreatePipelineAsyncStatus status, RenderPipeline pipeline, const char* message)>,
               typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
     Future CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CallbackMode callbackMode,L callback) const;
+    inline ResourceTable CreateResourceTable(ResourceTableDescriptor const * descriptor) const;
     inline Sampler CreateSampler(SamplerDescriptor const * descriptor = nullptr) const;
     inline ShaderModule CreateShaderModule(ShaderModuleDescriptor const * descriptor) const;
     inline Texture CreateTexture(TextureDescriptor const * descriptor) const;
@@ -1942,84 +1932,37 @@ class RenderBundle : public ObjectBase<RenderBundle, WGPURenderBundle> {
     static inline void WGPURelease(WGPURenderBundle handle);
 };
 
-class RenderBundleEncoder : public ObjectBase<RenderBundleEncoder, WGPURenderBundleEncoder> {
-  public:
-    using ObjectBase::ObjectBase;
-    using ObjectBase::operator=;
-
-    inline void Draw(uint32_t vertexCount, uint32_t instanceCount = 1, uint32_t firstVertex = 0, uint32_t firstInstance = 0) const;
-    inline void DrawIndexed(uint32_t indexCount, uint32_t instanceCount = 1, uint32_t firstIndex = 0, int32_t baseVertex = 0, uint32_t firstInstance = 0) const;
-    inline void DrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const;
-    inline void DrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const;
-    inline RenderBundle Finish(RenderBundleDescriptor const * descriptor = nullptr) const;
-    inline void InsertDebugMarker(StringView markerLabel) const;
-    inline void PopDebugGroup() const;
-    inline void PushDebugGroup(StringView groupLabel) const;
-    inline void SetBindGroup(uint32_t groupIndex, BindGroup const& group = nullptr, size_t dynamicOffsetCount = 0, uint32_t const * dynamicOffsets = nullptr) const;
-    inline void SetImmediateData(uint32_t offset, void const * data, size_t size) const;
-    inline void SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset = 0, uint64_t size = kWholeSize) const;
-    inline void SetLabel(StringView label) const;
-    inline void SetPipeline(RenderPipeline const& pipeline) const;
-    inline void SetVertexBuffer(uint32_t slot, Buffer const& buffer = nullptr, uint64_t offset = 0, uint64_t size = kWholeSize) const;
-
-
-  private:
-    friend ObjectBase<RenderBundleEncoder, WGPURenderBundleEncoder>;
-    static inline void WGPUAddRef(WGPURenderBundleEncoder handle);
-    static inline void WGPURelease(WGPURenderBundleEncoder handle);
-};
-
-class RenderPassEncoder : public ObjectBase<RenderPassEncoder, WGPURenderPassEncoder> {
+class RenderPipeline : public ObjectBase<RenderPipeline, WGPURenderPipeline> {
   public:
     using ObjectBase::ObjectBase;
     using ObjectBase::operator=;
 
-    inline void BeginOcclusionQuery(uint32_t queryIndex) const;
-    inline void Draw(uint32_t vertexCount, uint32_t instanceCount = 1, uint32_t firstVertex = 0, uint32_t firstInstance = 0) const;
-    inline void DrawIndexed(uint32_t indexCount, uint32_t instanceCount = 1, uint32_t firstIndex = 0, int32_t baseVertex = 0, uint32_t firstInstance = 0) const;
-    inline void DrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const;
-    inline void DrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const;
-    inline void End() const;
-    inline void EndOcclusionQuery() const;
-    inline void ExecuteBundles(size_t bundleCount, RenderBundle const * bundles) const;
-    inline void InsertDebugMarker(StringView markerLabel) const;
-    inline void MultiDrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset, uint32_t maxDrawCount, Buffer const& drawCountBuffer = nullptr, uint64_t drawCountBufferOffset = 0) const;
-    inline void MultiDrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset, uint32_t maxDrawCount, Buffer const& drawCountBuffer = nullptr, uint64_t drawCountBufferOffset = 0) const;
-    inline void PixelLocalStorageBarrier() const;
-    inline void PopDebugGroup() const;
-    inline void PushDebugGroup(StringView groupLabel) const;
-    inline void SetBindGroup(uint32_t groupIndex, BindGroup const& group = nullptr, size_t dynamicOffsetCount = 0, uint32_t const * dynamicOffsets = nullptr) const;
-    inline void SetBlendConstant(Color const * color) const;
-    inline void SetImmediateData(uint32_t offset, void const * data, size_t size) const;
-    inline void SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset = 0, uint64_t size = kWholeSize) const;
+    inline BindGroupLayout GetBindGroupLayout(uint32_t groupIndex) const;
     inline void SetLabel(StringView label) const;
-    inline void SetPipeline(RenderPipeline const& pipeline) const;
-    inline void SetScissorRect(uint32_t x, uint32_t y, uint32_t width, uint32_t height) const;
-    inline void SetStencilReference(uint32_t reference) const;
-    inline void SetVertexBuffer(uint32_t slot, Buffer const& buffer = nullptr, uint64_t offset = 0, uint64_t size = kWholeSize) const;
-    inline void SetViewport(float x, float y, float width, float height, float minDepth, float maxDepth) const;
-    inline void WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const;
 
 
   private:
-    friend ObjectBase<RenderPassEncoder, WGPURenderPassEncoder>;
-    static inline void WGPUAddRef(WGPURenderPassEncoder handle);
-    static inline void WGPURelease(WGPURenderPassEncoder handle);
+    friend ObjectBase<RenderPipeline, WGPURenderPipeline>;
+    static inline void WGPUAddRef(WGPURenderPipeline handle);
+    static inline void WGPURelease(WGPURenderPipeline handle);
 };
 
-class RenderPipeline : public ObjectBase<RenderPipeline, WGPURenderPipeline> {
+class ResourceTable : public ObjectBase<ResourceTable, WGPUResourceTable> {
   public:
     using ObjectBase::ObjectBase;
     using ObjectBase::operator=;
 
-    inline BindGroupLayout GetBindGroupLayout(uint32_t groupIndex) const;
-    inline void SetLabel(StringView label) const;
+    inline void Destroy() const;
+    inline uint32_t GetSize() const;
+    inline uint32_t InsertBinding(BindingResource const * resource) const;
+    inline ConvertibleStatus RemoveBinding(uint32_t slot) const;
+    inline ConvertibleStatus Update(uint32_t slot, BindingResource const * resource) const;
 
 
   private:
-    friend ObjectBase<RenderPipeline, WGPURenderPipeline>;
-    static inline void WGPUAddRef(WGPURenderPipeline handle);
-    static inline void WGPURelease(WGPURenderPipeline handle);
+    friend ObjectBase<ResourceTable, WGPUResourceTable>;
+    static inline void WGPUAddRef(WGPUResourceTable handle);
+    static inline void WGPURelease(WGPUResourceTable handle);
 };
 
 class Sampler : public ObjectBase<Sampler, WGPUSampler> {
@@ -2085,6 +2028,7 @@ class SharedFence : public ObjectBase<SharedFence, WGPUSharedFence> {
     using ObjectBase::operator=;
 
     inline void ExportInfo(SharedFenceExportInfo * info) const;
+    inline void SetLabel(StringView label) const;
 
 
   private:
@@ -2159,10 +2103,12 @@ class Texture : public ObjectBase<Texture, WGPUTexture> {
     inline uint32_t GetHeight() const;
     inline uint32_t GetMipLevelCount() const;
     inline uint32_t GetSampleCount() const;
+    inline TextureViewDimension GetTextureBindingViewDimension() const;
     inline TextureUsage GetUsage() const;
     inline uint32_t GetWidth() const;
     inline void Pin(TextureUsage usage) const;
     inline void SetLabel(StringView label) const;
+    inline void SetOwnershipForMemoryDump(uint64_t ownerGuid = 0) const;
     inline void Unpin() const;
 
 
@@ -2186,6 +2132,98 @@ class TextureView : public ObjectBase<TextureView, WGPUTextureView> {
     static inline void WGPURelease(WGPUTextureView handle);
 };
 
+class ComputePassEncoder : public ObjectBase<ComputePassEncoder, WGPUComputePassEncoder> {
+  public:
+    using ObjectBase::ObjectBase;
+    using ObjectBase::operator=;
+
+    inline void DispatchWorkgroups(uint32_t workgroupCountX, uint32_t workgroupCountY = 1, uint32_t workgroupCountZ = 1) const;
+    inline void DispatchWorkgroupsIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const;
+    inline void End() const;
+    inline void InsertDebugMarker(StringView markerLabel) const;
+    inline void PopDebugGroup() const;
+    inline void PushDebugGroup(StringView groupLabel) const;
+    inline void SetBindGroup(uint32_t groupIndex, BindGroup const& group = nullptr, size_t dynamicOffsetCount = 0, uint32_t const * dynamicOffsets = nullptr) const;
+    inline void SetImmediates(uint32_t offset, void const * data, size_t size) const;
+    inline void SetLabel(StringView label) const;
+    inline void SetPipeline(ComputePipeline const& pipeline) const;
+    inline void SetResourceTable(ResourceTable const& table = nullptr) const;
+    inline void WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const;
+
+
+  private:
+    friend ObjectBase<ComputePassEncoder, WGPUComputePassEncoder>;
+    static inline void WGPUAddRef(WGPUComputePassEncoder handle);
+    static inline void WGPURelease(WGPUComputePassEncoder handle);
+};
+
+class RenderBundleEncoder : public ObjectBase<RenderBundleEncoder, WGPURenderBundleEncoder> {
+  public:
+    using ObjectBase::ObjectBase;
+    using ObjectBase::operator=;
+
+    inline void Draw(uint32_t vertexCount, uint32_t instanceCount = 1, uint32_t firstVertex = 0, uint32_t firstInstance = 0) const;
+    inline void DrawIndexed(uint32_t indexCount, uint32_t instanceCount = 1, uint32_t firstIndex = 0, int32_t baseVertex = 0, uint32_t firstInstance = 0) const;
+    inline void DrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const;
+    inline void DrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const;
+    inline RenderBundle Finish(RenderBundleDescriptor const * descriptor = nullptr) const;
+    inline void InsertDebugMarker(StringView markerLabel) const;
+    inline void PopDebugGroup() const;
+    inline void PushDebugGroup(StringView groupLabel) const;
+    inline void SetBindGroup(uint32_t groupIndex, BindGroup const& group = nullptr, size_t dynamicOffsetCount = 0, uint32_t const * dynamicOffsets = nullptr) const;
+    inline void SetImmediates(uint32_t offset, void const * data, size_t size) const;
+    inline void SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset = 0, uint64_t size = kWholeSize) const;
+    inline void SetLabel(StringView label) const;
+    inline void SetPipeline(RenderPipeline const& pipeline) const;
+    inline void SetResourceTable(ResourceTable const& table = nullptr) const;
+    inline void SetVertexBuffer(uint32_t slot, Buffer const& buffer = nullptr, uint64_t offset = 0, uint64_t size = kWholeSize) const;
+
+
+  private:
+    friend ObjectBase<RenderBundleEncoder, WGPURenderBundleEncoder>;
+    static inline void WGPUAddRef(WGPURenderBundleEncoder handle);
+    static inline void WGPURelease(WGPURenderBundleEncoder handle);
+};
+
+class RenderPassEncoder : public ObjectBase<RenderPassEncoder, WGPURenderPassEncoder> {
+  public:
+    using ObjectBase::ObjectBase;
+    using ObjectBase::operator=;
+
+    inline void BeginOcclusionQuery(uint32_t queryIndex) const;
+    inline void Draw(uint32_t vertexCount, uint32_t instanceCount = 1, uint32_t firstVertex = 0, uint32_t firstInstance = 0) const;
+    inline void DrawIndexed(uint32_t indexCount, uint32_t instanceCount = 1, uint32_t firstIndex = 0, int32_t baseVertex = 0, uint32_t firstInstance = 0) const;
+    inline void DrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const;
+    inline void DrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const;
+    inline void End() const;
+    inline void EndOcclusionQuery() const;
+    inline void ExecuteBundles(size_t bundleCount, RenderBundle const * bundles) const;
+    inline void InsertDebugMarker(StringView markerLabel) const;
+    inline void MultiDrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset, uint32_t maxDrawCount, Buffer const& drawCountBuffer = nullptr, uint64_t drawCountBufferOffset = 0) const;
+    inline void MultiDrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset, uint32_t maxDrawCount, Buffer const& drawCountBuffer = nullptr, uint64_t drawCountBufferOffset = 0) const;
+    inline void PixelLocalStorageBarrier() const;
+    inline void PopDebugGroup() const;
+    inline void PushDebugGroup(StringView groupLabel) const;
+    inline void SetBindGroup(uint32_t groupIndex, BindGroup const& group = nullptr, size_t dynamicOffsetCount = 0, uint32_t const * dynamicOffsets = nullptr) const;
+    inline void SetBlendConstant(Color const * color) const;
+    inline void SetImmediates(uint32_t offset, void const * data, size_t size) const;
+    inline void SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset = 0, uint64_t size = kWholeSize) const;
+    inline void SetLabel(StringView label) const;
+    inline void SetPipeline(RenderPipeline const& pipeline) const;
+    inline void SetResourceTable(ResourceTable const& table = nullptr) const;
+    inline void SetScissorRect(uint32_t x, uint32_t y, uint32_t width, uint32_t height) const;
+    inline void SetStencilReference(uint32_t reference) const;
+    inline void SetVertexBuffer(uint32_t slot, Buffer const& buffer = nullptr, uint64_t offset = 0, uint64_t size = kWholeSize) const;
+    inline void SetViewport(float x, float y, float width, float height, float minDepth, float maxDepth) const;
+    inline void WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const;
+
+
+  private:
+    friend ObjectBase<RenderPassEncoder, WGPURenderPassEncoder>;
+    static inline void WGPUAddRef(WGPURenderPassEncoder handle);
+    static inline void WGPURelease(WGPURenderPassEncoder handle);
+};
+
 
 // ChainedStruct
 static_assert(sizeof(ChainedStruct) == sizeof(WGPUChainedStruct),
@@ -2210,6 +2248,20 @@ struct AdapterPropertiesD3D : ChainedStructOut {
     alignas(kFirstMemberAlignment) uint32_t shaderModel;
 };
 
+// Can be chained in AdapterInfo
+struct AdapterPropertiesExplicitComputeSubgroupSizeConfigs : ChainedStructOut {
+    inline AdapterPropertiesExplicitComputeSubgroupSizeConfigs();
+
+    struct Init;
+    inline AdapterPropertiesExplicitComputeSubgroupSizeConfigs(Init&& init);
+    inline operator const WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
+    alignas(kFirstMemberAlignment) uint32_t minExplicitComputeSubgroupSize;
+    uint32_t maxExplicitComputeSubgroupSize;
+    uint32_t maxComputeWorkgroupSubgroups;
+};
+
 // Can be chained in AdapterInfo
 struct AdapterPropertiesVk : ChainedStructOut {
     inline AdapterPropertiesVk();
@@ -2234,16 +2286,15 @@ struct AdapterPropertiesWGPU : ChainedStructOut {
     alignas(kFirstMemberAlignment) BackendType backendType = BackendType::Undefined;
 };
 
-// Can be chained in BindGroupDescriptor
-struct BindGroupDynamicBindingArray : ChainedStruct {
-    inline BindGroupDynamicBindingArray();
-
-    struct Init;
-    inline BindGroupDynamicBindingArray(Init&& init);
-    inline operator const WGPUBindGroupDynamicBindingArray&() const noexcept;
+struct BindingResource {
+    inline operator const WGPUBindingResource&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
-    alignas(kFirstMemberAlignment) uint32_t dynamicArraySize = 0;
+    ChainedStruct const * nextInChain = nullptr;
+    Buffer buffer = nullptr;
+    uint64_t offset = 0;
+    uint64_t size = kWholeSize;
+    Sampler sampler = nullptr;
+    TextureView textureView = nullptr;
 };
 
 struct BlendComponent {
@@ -2485,16 +2536,16 @@ struct DawnInjectedInvalidSType : ChainedStruct {
     alignas(kFirstMemberAlignment) SType invalidSType = {};
 };
 
-// Can be chained in RenderPassColorAttachment
-struct DawnRenderPassColorAttachmentRenderToSingleSampled : ChainedStruct {
-    inline DawnRenderPassColorAttachmentRenderToSingleSampled();
+// Can be chained in RenderPassDescriptor
+struct DawnRenderPassSampleCount : ChainedStruct {
+    inline DawnRenderPassSampleCount();
 
     struct Init;
-    inline DawnRenderPassColorAttachmentRenderToSingleSampled(Init&& init);
-    inline operator const WGPUDawnRenderPassColorAttachmentRenderToSingleSampled&() const noexcept;
+    inline DawnRenderPassSampleCount(Init&& init);
+    inline operator const WGPUDawnRenderPassSampleCount&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
-    alignas(kFirstMemberAlignment) uint32_t implicitSampleCount = 1;
+    alignas(kFirstMemberAlignment) uint32_t sampleCount = 1;
 };
 
 // Can be chained in ShaderModuleDescriptor
@@ -2577,26 +2628,6 @@ struct DawnWireWGSLControl : ChainedStruct {
     Bool enableTesting = false;
 };
 
-struct DynamicBindingArrayLayout {
-    inline operator const WGPUDynamicBindingArrayLayout&() const noexcept;
-
-    ChainedStruct const * nextInChain = nullptr;
-    uint32_t start = 0;
-    DynamicBindingKind kind = DynamicBindingKind::Undefined;
-};
-
-// Can be chained in Limits
-struct DynamicBindingArrayLimits : ChainedStructOut {
-    inline DynamicBindingArrayLimits();
-
-    struct Init;
-    inline DynamicBindingArrayLimits(Init&& init);
-    inline operator const WGPUDynamicBindingArrayLimits&() const noexcept;
-
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
-    alignas(kFirstMemberAlignment) uint32_t maxDynamicBindingArraySize = kLimitU32Undefined;
-};
-
 // Can be chained in SurfaceDescriptor
 struct EmscriptenSurfaceSourceCanvasHTMLSelector : ChainedStruct {
     inline EmscriptenSurfaceSourceCanvasHTMLSelector();
@@ -2705,6 +2736,18 @@ struct PassTimestampWrites {
     uint32_t endOfPassWriteIndex = kQuerySetIndexUndefined;
 };
 
+// Can be chained in PipelineLayoutDescriptor
+struct PipelineLayoutResourceTable : ChainedStruct {
+    inline PipelineLayoutResourceTable();
+
+    struct Init;
+    inline PipelineLayoutResourceTable(Init&& init);
+    inline operator const WGPUPipelineLayoutResourceTable&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
+    alignas(kFirstMemberAlignment) Bool usesResourceTable = false;
+};
+
 struct PipelineLayoutStorageAttachment {
     inline operator const WGPUPipelineLayoutStorageAttachment&() const noexcept;
 
@@ -2775,21 +2818,6 @@ struct RenderPassDepthStencilAttachment {
     Bool stencilReadOnly = false;
 };
 
-// Can be chained in RenderPassDescriptor
-struct RenderPassDescriptorExpandResolveRect : ChainedStruct {
-    inline RenderPassDescriptorExpandResolveRect();
-
-    struct Init;
-    inline RenderPassDescriptorExpandResolveRect(Init&& init);
-    inline operator const WGPURenderPassDescriptorExpandResolveRect&() const noexcept;
-
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
-    alignas(kFirstMemberAlignment) uint32_t x;
-    uint32_t y;
-    uint32_t width;
-    uint32_t height;
-};
-
 // Can be chained in RenderPassDescriptor
 struct RenderPassDescriptorResolveRect : ChainedStruct {
     inline RenderPassDescriptorResolveRect();
@@ -2841,6 +2869,14 @@ struct RequestAdapterWebXROptions : ChainedStruct {
     alignas(kFirstMemberAlignment) Bool xrCompatible;
 };
 
+struct ResourceTableDescriptor {
+    inline operator const WGPUResourceTableDescriptor&() const noexcept;
+
+    ChainedStruct const * nextInChain = nullptr;
+    StringView label = {};
+    uint32_t size;
+};
+
 struct SamplerBindingLayout {
     inline operator const WGPUSamplerBindingLayout&() const noexcept;
 
@@ -2895,14 +2931,20 @@ struct SharedBufferMemoryBeginAccessDescriptor {
     uint64_t const * signaledValues = nullptr;
 };
 
-struct SharedBufferMemoryDescriptor {
-    inline operator const WGPUSharedBufferMemoryDescriptor&() const noexcept;
+// Can be chained in SharedBufferMemoryDescriptor
+struct SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor : ChainedStruct {
+    inline SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor();
 
-    ChainedStruct const * nextInChain = nullptr;
-    StringView label = {};
-};
+    struct Init;
+    inline SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor(Init&& init);
+    inline operator const WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor&() const noexcept;
 
-struct SharedBufferMemoryEndAccessState {
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
+    alignas(kFirstMemberAlignment) void * handle;
+    uint64_t size;
+};
+
+struct SharedBufferMemoryEndAccessState {
     inline SharedBufferMemoryEndAccessState();
     inline ~SharedBufferMemoryEndAccessState();
     SharedBufferMemoryEndAccessState(const SharedBufferMemoryEndAccessState&) = delete;
@@ -3084,7 +3126,6 @@ struct SharedTextureMemoryAHardwareBufferDescriptor : ChainedStruct {
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
     alignas(kFirstMemberAlignment) void * handle;
-    Bool useExternalFormat;
 };
 
 // Can be chained in SharedTextureMemoryBeginAccessDescriptor
@@ -3540,12 +3581,12 @@ struct TextureBindingLayout {
 };
 
 // Can be chained in TextureDescriptor
-struct TextureBindingViewDimensionDescriptor : ChainedStruct {
-    inline TextureBindingViewDimensionDescriptor();
+struct TextureBindingViewDimension : ChainedStruct {
+    inline TextureBindingViewDimension();
 
     struct Init;
-    inline TextureBindingViewDimensionDescriptor(Init&& init);
-    inline operator const WGPUTextureBindingViewDimensionDescriptor&() const noexcept;
+    inline TextureBindingViewDimension(Init&& init);
+    inline operator const WGPUTextureBindingViewDimension&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TextureViewDimension));
     alignas(kFirstMemberAlignment) TextureViewDimension textureBindingViewDimension = TextureViewDimension::Undefined;
@@ -3655,18 +3696,6 @@ struct BindGroupEntry {
     TextureView textureView = nullptr;
 };
 
-// Can be chained in BindGroupLayoutDescriptor
-struct BindGroupLayoutDynamicBindingArray : ChainedStruct {
-    inline BindGroupLayoutDynamicBindingArray();
-
-    struct Init;
-    inline BindGroupLayoutDynamicBindingArray(Init&& init);
-    inline operator const WGPUBindGroupLayoutDynamicBindingArray&() const noexcept;
-
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(DynamicBindingArrayLayout));
-    alignas(kFirstMemberAlignment) DynamicBindingArrayLayout dynamicArray = {};
-};
-
 struct BindGroupLayoutEntry {
     inline operator const WGPUBindGroupLayoutEntry&() const noexcept;
 
@@ -3880,6 +3909,19 @@ struct RenderPassColorAttachment {
     Color clearValue = {};
 };
 
+// Can be chained in RenderPassDescriptor
+struct RenderPassRenderAreaRect : ChainedStruct {
+    inline RenderPassRenderAreaRect();
+
+    struct Init;
+    inline RenderPassRenderAreaRect(Init&& init);
+    inline operator const WGPURenderPassRenderAreaRect&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Origin2D));
+    alignas(kFirstMemberAlignment) Origin2D origin = {};
+    Extent2D size = {};
+};
+
 struct RenderPassStorageAttachment {
     inline operator const WGPURenderPassStorageAttachment&() const noexcept;
 
@@ -3926,6 +3968,13 @@ struct ShaderModuleDescriptor {
     StringView label = {};
 };
 
+struct SharedBufferMemoryDescriptor {
+    inline operator const WGPUSharedBufferMemoryDescriptor&() const noexcept;
+
+    ChainedStruct const * nextInChain = nullptr;
+    StringView label = {};
+};
+
 struct SharedFenceDescriptor {
     inline operator const WGPUSharedFenceDescriptor&() const noexcept;
 
@@ -4324,6 +4373,34 @@ static_assert(alignof(AdapterPropertiesD3D) == alignof(WGPUAdapterPropertiesD3D)
 static_assert(offsetof(AdapterPropertiesD3D, shaderModel) == offsetof(WGPUAdapterPropertiesD3D, shaderModel),
         "offsetof mismatch for AdapterPropertiesD3D::shaderModel");
 
+// AdapterPropertiesExplicitComputeSubgroupSizeConfigs implementation
+AdapterPropertiesExplicitComputeSubgroupSizeConfigs::AdapterPropertiesExplicitComputeSubgroupSizeConfigs()
+  : ChainedStructOut { nullptr, SType::AdapterPropertiesExplicitComputeSubgroupSizeConfigs } {}
+struct AdapterPropertiesExplicitComputeSubgroupSizeConfigs::Init {
+    ChainedStructOut *  nextInChain;
+    uint32_t minExplicitComputeSubgroupSize;
+    uint32_t maxExplicitComputeSubgroupSize;
+    uint32_t maxComputeWorkgroupSubgroups;
+};
+AdapterPropertiesExplicitComputeSubgroupSizeConfigs::AdapterPropertiesExplicitComputeSubgroupSizeConfigs(AdapterPropertiesExplicitComputeSubgroupSizeConfigs::Init&& init)
+  : ChainedStructOut { init.nextInChain, SType::AdapterPropertiesExplicitComputeSubgroupSizeConfigs }, 
+    minExplicitComputeSubgroupSize(std::move(init.minExplicitComputeSubgroupSize)), 
+    maxExplicitComputeSubgroupSize(std::move(init.maxExplicitComputeSubgroupSize)), 
+    maxComputeWorkgroupSubgroups(std::move(init.maxComputeWorkgroupSubgroups)){}
+
+AdapterPropertiesExplicitComputeSubgroupSizeConfigs::operator const WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs&() const noexcept {
+    return *reinterpret_cast<const WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs*>(this);
+}
+
+static_assert(sizeof(AdapterPropertiesExplicitComputeSubgroupSizeConfigs) == sizeof(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs), "sizeof mismatch for AdapterPropertiesExplicitComputeSubgroupSizeConfigs");
+static_assert(alignof(AdapterPropertiesExplicitComputeSubgroupSizeConfigs) == alignof(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs), "alignof mismatch for AdapterPropertiesExplicitComputeSubgroupSizeConfigs");
+static_assert(offsetof(AdapterPropertiesExplicitComputeSubgroupSizeConfigs, minExplicitComputeSubgroupSize) == offsetof(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs, minExplicitComputeSubgroupSize),
+        "offsetof mismatch for AdapterPropertiesExplicitComputeSubgroupSizeConfigs::minExplicitComputeSubgroupSize");
+static_assert(offsetof(AdapterPropertiesExplicitComputeSubgroupSizeConfigs, maxExplicitComputeSubgroupSize) == offsetof(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs, maxExplicitComputeSubgroupSize),
+        "offsetof mismatch for AdapterPropertiesExplicitComputeSubgroupSizeConfigs::maxExplicitComputeSubgroupSize");
+static_assert(offsetof(AdapterPropertiesExplicitComputeSubgroupSizeConfigs, maxComputeWorkgroupSubgroups) == offsetof(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs, maxComputeWorkgroupSubgroups),
+        "offsetof mismatch for AdapterPropertiesExplicitComputeSubgroupSizeConfigs::maxComputeWorkgroupSubgroups");
+
 // AdapterPropertiesVk implementation
 AdapterPropertiesVk::AdapterPropertiesVk()
   : ChainedStructOut { nullptr, SType::AdapterPropertiesVk } {}
@@ -4364,25 +4441,26 @@ static_assert(alignof(AdapterPropertiesWGPU) == alignof(WGPUAdapterPropertiesWGP
 static_assert(offsetof(AdapterPropertiesWGPU, backendType) == offsetof(WGPUAdapterPropertiesWGPU, backendType),
         "offsetof mismatch for AdapterPropertiesWGPU::backendType");
 
-// BindGroupDynamicBindingArray implementation
-BindGroupDynamicBindingArray::BindGroupDynamicBindingArray()
-  : ChainedStruct { nullptr, SType::BindGroupDynamicBindingArray } {}
-struct BindGroupDynamicBindingArray::Init {
-    ChainedStruct * const nextInChain;
-    uint32_t dynamicArraySize = 0;
-};
-BindGroupDynamicBindingArray::BindGroupDynamicBindingArray(BindGroupDynamicBindingArray::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::BindGroupDynamicBindingArray }, 
-    dynamicArraySize(std::move(init.dynamicArraySize)){}
+// BindingResource implementation
 
-BindGroupDynamicBindingArray::operator const WGPUBindGroupDynamicBindingArray&() const noexcept {
-    return *reinterpret_cast<const WGPUBindGroupDynamicBindingArray*>(this);
+BindingResource::operator const WGPUBindingResource&() const noexcept {
+    return *reinterpret_cast<const WGPUBindingResource*>(this);
 }
 
-static_assert(sizeof(BindGroupDynamicBindingArray) == sizeof(WGPUBindGroupDynamicBindingArray), "sizeof mismatch for BindGroupDynamicBindingArray");
-static_assert(alignof(BindGroupDynamicBindingArray) == alignof(WGPUBindGroupDynamicBindingArray), "alignof mismatch for BindGroupDynamicBindingArray");
-static_assert(offsetof(BindGroupDynamicBindingArray, dynamicArraySize) == offsetof(WGPUBindGroupDynamicBindingArray, dynamicArraySize),
-        "offsetof mismatch for BindGroupDynamicBindingArray::dynamicArraySize");
+static_assert(sizeof(BindingResource) == sizeof(WGPUBindingResource), "sizeof mismatch for BindingResource");
+static_assert(alignof(BindingResource) == alignof(WGPUBindingResource), "alignof mismatch for BindingResource");
+static_assert(offsetof(BindingResource, nextInChain) == offsetof(WGPUBindingResource, nextInChain),
+        "offsetof mismatch for BindingResource::nextInChain");
+static_assert(offsetof(BindingResource, buffer) == offsetof(WGPUBindingResource, buffer),
+        "offsetof mismatch for BindingResource::buffer");
+static_assert(offsetof(BindingResource, offset) == offsetof(WGPUBindingResource, offset),
+        "offsetof mismatch for BindingResource::offset");
+static_assert(offsetof(BindingResource, size) == offsetof(WGPUBindingResource, size),
+        "offsetof mismatch for BindingResource::size");
+static_assert(offsetof(BindingResource, sampler) == offsetof(WGPUBindingResource, sampler),
+        "offsetof mismatch for BindingResource::sampler");
+static_assert(offsetof(BindingResource, textureView) == offsetof(WGPUBindingResource, textureView),
+        "offsetof mismatch for BindingResource::textureView");
 
 // BlendComponent implementation
 
@@ -4825,25 +4903,25 @@ static_assert(alignof(DawnInjectedInvalidSType) == alignof(WGPUDawnInjectedInval
 static_assert(offsetof(DawnInjectedInvalidSType, invalidSType) == offsetof(WGPUDawnInjectedInvalidSType, invalidSType),
         "offsetof mismatch for DawnInjectedInvalidSType::invalidSType");
 
-// DawnRenderPassColorAttachmentRenderToSingleSampled implementation
-DawnRenderPassColorAttachmentRenderToSingleSampled::DawnRenderPassColorAttachmentRenderToSingleSampled()
-  : ChainedStruct { nullptr, SType::DawnRenderPassColorAttachmentRenderToSingleSampled } {}
-struct DawnRenderPassColorAttachmentRenderToSingleSampled::Init {
+// DawnRenderPassSampleCount implementation
+DawnRenderPassSampleCount::DawnRenderPassSampleCount()
+  : ChainedStruct { nullptr, SType::DawnRenderPassSampleCount } {}
+struct DawnRenderPassSampleCount::Init {
     ChainedStruct * const nextInChain;
-    uint32_t implicitSampleCount = 1;
+    uint32_t sampleCount = 1;
 };
-DawnRenderPassColorAttachmentRenderToSingleSampled::DawnRenderPassColorAttachmentRenderToSingleSampled(DawnRenderPassColorAttachmentRenderToSingleSampled::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnRenderPassColorAttachmentRenderToSingleSampled }, 
-    implicitSampleCount(std::move(init.implicitSampleCount)){}
+DawnRenderPassSampleCount::DawnRenderPassSampleCount(DawnRenderPassSampleCount::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::DawnRenderPassSampleCount }, 
+    sampleCount(std::move(init.sampleCount)){}
 
-DawnRenderPassColorAttachmentRenderToSingleSampled::operator const WGPUDawnRenderPassColorAttachmentRenderToSingleSampled&() const noexcept {
-    return *reinterpret_cast<const WGPUDawnRenderPassColorAttachmentRenderToSingleSampled*>(this);
+DawnRenderPassSampleCount::operator const WGPUDawnRenderPassSampleCount&() const noexcept {
+    return *reinterpret_cast<const WGPUDawnRenderPassSampleCount*>(this);
 }
 
-static_assert(sizeof(DawnRenderPassColorAttachmentRenderToSingleSampled) == sizeof(WGPUDawnRenderPassColorAttachmentRenderToSingleSampled), "sizeof mismatch for DawnRenderPassColorAttachmentRenderToSingleSampled");
-static_assert(alignof(DawnRenderPassColorAttachmentRenderToSingleSampled) == alignof(WGPUDawnRenderPassColorAttachmentRenderToSingleSampled), "alignof mismatch for DawnRenderPassColorAttachmentRenderToSingleSampled");
-static_assert(offsetof(DawnRenderPassColorAttachmentRenderToSingleSampled, implicitSampleCount) == offsetof(WGPUDawnRenderPassColorAttachmentRenderToSingleSampled, implicitSampleCount),
-        "offsetof mismatch for DawnRenderPassColorAttachmentRenderToSingleSampled::implicitSampleCount");
+static_assert(sizeof(DawnRenderPassSampleCount) == sizeof(WGPUDawnRenderPassSampleCount), "sizeof mismatch for DawnRenderPassSampleCount");
+static_assert(alignof(DawnRenderPassSampleCount) == alignof(WGPUDawnRenderPassSampleCount), "alignof mismatch for DawnRenderPassSampleCount");
+static_assert(offsetof(DawnRenderPassSampleCount, sampleCount) == offsetof(WGPUDawnRenderPassSampleCount, sampleCount),
+        "offsetof mismatch for DawnRenderPassSampleCount::sampleCount");
 
 // DawnShaderModuleSPIRVOptionsDescriptor implementation
 DawnShaderModuleSPIRVOptionsDescriptor::DawnShaderModuleSPIRVOptionsDescriptor()
@@ -4989,41 +5067,6 @@ static_assert(offsetof(DawnWireWGSLControl, enableUnsafe) == offsetof(WGPUDawnWi
 static_assert(offsetof(DawnWireWGSLControl, enableTesting) == offsetof(WGPUDawnWireWGSLControl, enableTesting),
         "offsetof mismatch for DawnWireWGSLControl::enableTesting");
 
-// DynamicBindingArrayLayout implementation
-
-DynamicBindingArrayLayout::operator const WGPUDynamicBindingArrayLayout&() const noexcept {
-    return *reinterpret_cast<const WGPUDynamicBindingArrayLayout*>(this);
-}
-
-static_assert(sizeof(DynamicBindingArrayLayout) == sizeof(WGPUDynamicBindingArrayLayout), "sizeof mismatch for DynamicBindingArrayLayout");
-static_assert(alignof(DynamicBindingArrayLayout) == alignof(WGPUDynamicBindingArrayLayout), "alignof mismatch for DynamicBindingArrayLayout");
-static_assert(offsetof(DynamicBindingArrayLayout, nextInChain) == offsetof(WGPUDynamicBindingArrayLayout, nextInChain),
-        "offsetof mismatch for DynamicBindingArrayLayout::nextInChain");
-static_assert(offsetof(DynamicBindingArrayLayout, start) == offsetof(WGPUDynamicBindingArrayLayout, start),
-        "offsetof mismatch for DynamicBindingArrayLayout::start");
-static_assert(offsetof(DynamicBindingArrayLayout, kind) == offsetof(WGPUDynamicBindingArrayLayout, kind),
-        "offsetof mismatch for DynamicBindingArrayLayout::kind");
-
-// DynamicBindingArrayLimits implementation
-DynamicBindingArrayLimits::DynamicBindingArrayLimits()
-  : ChainedStructOut { nullptr, SType::DynamicBindingArrayLimits } {}
-struct DynamicBindingArrayLimits::Init {
-    ChainedStructOut *  nextInChain;
-    uint32_t maxDynamicBindingArraySize = kLimitU32Undefined;
-};
-DynamicBindingArrayLimits::DynamicBindingArrayLimits(DynamicBindingArrayLimits::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::DynamicBindingArrayLimits }, 
-    maxDynamicBindingArraySize(std::move(init.maxDynamicBindingArraySize)){}
-
-DynamicBindingArrayLimits::operator const WGPUDynamicBindingArrayLimits&() const noexcept {
-    return *reinterpret_cast<const WGPUDynamicBindingArrayLimits*>(this);
-}
-
-static_assert(sizeof(DynamicBindingArrayLimits) == sizeof(WGPUDynamicBindingArrayLimits), "sizeof mismatch for DynamicBindingArrayLimits");
-static_assert(alignof(DynamicBindingArrayLimits) == alignof(WGPUDynamicBindingArrayLimits), "alignof mismatch for DynamicBindingArrayLimits");
-static_assert(offsetof(DynamicBindingArrayLimits, maxDynamicBindingArraySize) == offsetof(WGPUDynamicBindingArrayLimits, maxDynamicBindingArraySize),
-        "offsetof mismatch for DynamicBindingArrayLimits::maxDynamicBindingArraySize");
-
 // EmscriptenSurfaceSourceCanvasHTMLSelector implementation
 EmscriptenSurfaceSourceCanvasHTMLSelector::EmscriptenSurfaceSourceCanvasHTMLSelector()
   : ChainedStruct { nullptr, SType::EmscriptenSurfaceSourceCanvasHTMLSelector } {}
@@ -5218,6 +5261,26 @@ static_assert(offsetof(PassTimestampWrites, beginningOfPassWriteIndex) == offset
 static_assert(offsetof(PassTimestampWrites, endOfPassWriteIndex) == offsetof(WGPUPassTimestampWrites, endOfPassWriteIndex),
         "offsetof mismatch for PassTimestampWrites::endOfPassWriteIndex");
 
+// PipelineLayoutResourceTable implementation
+PipelineLayoutResourceTable::PipelineLayoutResourceTable()
+  : ChainedStruct { nullptr, SType::PipelineLayoutResourceTable } {}
+struct PipelineLayoutResourceTable::Init {
+    ChainedStruct * const nextInChain;
+    Bool usesResourceTable = false;
+};
+PipelineLayoutResourceTable::PipelineLayoutResourceTable(PipelineLayoutResourceTable::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::PipelineLayoutResourceTable }, 
+    usesResourceTable(std::move(init.usesResourceTable)){}
+
+PipelineLayoutResourceTable::operator const WGPUPipelineLayoutResourceTable&() const noexcept {
+    return *reinterpret_cast<const WGPUPipelineLayoutResourceTable*>(this);
+}
+
+static_assert(sizeof(PipelineLayoutResourceTable) == sizeof(WGPUPipelineLayoutResourceTable), "sizeof mismatch for PipelineLayoutResourceTable");
+static_assert(alignof(PipelineLayoutResourceTable) == alignof(WGPUPipelineLayoutResourceTable), "alignof mismatch for PipelineLayoutResourceTable");
+static_assert(offsetof(PipelineLayoutResourceTable, usesResourceTable) == offsetof(WGPUPipelineLayoutResourceTable, usesResourceTable),
+        "offsetof mismatch for PipelineLayoutResourceTable::usesResourceTable");
+
 // PipelineLayoutStorageAttachment implementation
 
 PipelineLayoutStorageAttachment::operator const WGPUPipelineLayoutStorageAttachment&() const noexcept {
@@ -5351,38 +5414,6 @@ static_assert(offsetof(RenderPassDepthStencilAttachment, stencilClearValue) == o
 static_assert(offsetof(RenderPassDepthStencilAttachment, stencilReadOnly) == offsetof(WGPURenderPassDepthStencilAttachment, stencilReadOnly),
         "offsetof mismatch for RenderPassDepthStencilAttachment::stencilReadOnly");
 
-// RenderPassDescriptorExpandResolveRect implementation
-RenderPassDescriptorExpandResolveRect::RenderPassDescriptorExpandResolveRect()
-  : ChainedStruct { nullptr, SType::RenderPassDescriptorExpandResolveRect } {}
-struct RenderPassDescriptorExpandResolveRect::Init {
-    ChainedStruct * const nextInChain;
-    uint32_t x;
-    uint32_t y;
-    uint32_t width;
-    uint32_t height;
-};
-RenderPassDescriptorExpandResolveRect::RenderPassDescriptorExpandResolveRect(RenderPassDescriptorExpandResolveRect::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::RenderPassDescriptorExpandResolveRect }, 
-    x(std::move(init.x)), 
-    y(std::move(init.y)), 
-    width(std::move(init.width)), 
-    height(std::move(init.height)){}
-
-RenderPassDescriptorExpandResolveRect::operator const WGPURenderPassDescriptorExpandResolveRect&() const noexcept {
-    return *reinterpret_cast<const WGPURenderPassDescriptorExpandResolveRect*>(this);
-}
-
-static_assert(sizeof(RenderPassDescriptorExpandResolveRect) == sizeof(WGPURenderPassDescriptorExpandResolveRect), "sizeof mismatch for RenderPassDescriptorExpandResolveRect");
-static_assert(alignof(RenderPassDescriptorExpandResolveRect) == alignof(WGPURenderPassDescriptorExpandResolveRect), "alignof mismatch for RenderPassDescriptorExpandResolveRect");
-static_assert(offsetof(RenderPassDescriptorExpandResolveRect, x) == offsetof(WGPURenderPassDescriptorExpandResolveRect, x),
-        "offsetof mismatch for RenderPassDescriptorExpandResolveRect::x");
-static_assert(offsetof(RenderPassDescriptorExpandResolveRect, y) == offsetof(WGPURenderPassDescriptorExpandResolveRect, y),
-        "offsetof mismatch for RenderPassDescriptorExpandResolveRect::y");
-static_assert(offsetof(RenderPassDescriptorExpandResolveRect, width) == offsetof(WGPURenderPassDescriptorExpandResolveRect, width),
-        "offsetof mismatch for RenderPassDescriptorExpandResolveRect::width");
-static_assert(offsetof(RenderPassDescriptorExpandResolveRect, height) == offsetof(WGPURenderPassDescriptorExpandResolveRect, height),
-        "offsetof mismatch for RenderPassDescriptorExpandResolveRect::height");
-
 // RenderPassDescriptorResolveRect implementation
 RenderPassDescriptorResolveRect::RenderPassDescriptorResolveRect()
   : ChainedStruct { nullptr, SType::RenderPassDescriptorResolveRect } {}
@@ -5479,6 +5510,21 @@ static_assert(alignof(RequestAdapterWebXROptions) == alignof(WGPURequestAdapterW
 static_assert(offsetof(RequestAdapterWebXROptions, xrCompatible) == offsetof(WGPURequestAdapterWebXROptions, xrCompatible),
         "offsetof mismatch for RequestAdapterWebXROptions::xrCompatible");
 
+// ResourceTableDescriptor implementation
+
+ResourceTableDescriptor::operator const WGPUResourceTableDescriptor&() const noexcept {
+    return *reinterpret_cast<const WGPUResourceTableDescriptor*>(this);
+}
+
+static_assert(sizeof(ResourceTableDescriptor) == sizeof(WGPUResourceTableDescriptor), "sizeof mismatch for ResourceTableDescriptor");
+static_assert(alignof(ResourceTableDescriptor) == alignof(WGPUResourceTableDescriptor), "alignof mismatch for ResourceTableDescriptor");
+static_assert(offsetof(ResourceTableDescriptor, nextInChain) == offsetof(WGPUResourceTableDescriptor, nextInChain),
+        "offsetof mismatch for ResourceTableDescriptor::nextInChain");
+static_assert(offsetof(ResourceTableDescriptor, label) == offsetof(WGPUResourceTableDescriptor, label),
+        "offsetof mismatch for ResourceTableDescriptor::label");
+static_assert(offsetof(ResourceTableDescriptor, size) == offsetof(WGPUResourceTableDescriptor, size),
+        "offsetof mismatch for ResourceTableDescriptor::size");
+
 // SamplerBindingLayout implementation
 
 SamplerBindingLayout::operator const WGPUSamplerBindingLayout&() const noexcept {
@@ -5575,18 +5621,29 @@ static_assert(offsetof(SharedBufferMemoryBeginAccessDescriptor, fences) == offse
 static_assert(offsetof(SharedBufferMemoryBeginAccessDescriptor, signaledValues) == offsetof(WGPUSharedBufferMemoryBeginAccessDescriptor, signaledValues),
         "offsetof mismatch for SharedBufferMemoryBeginAccessDescriptor::signaledValues");
 
-// SharedBufferMemoryDescriptor implementation
+// SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor implementation
+SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor()
+  : ChainedStruct { nullptr, SType::SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor } {}
+struct SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::Init {
+    ChainedStruct * const nextInChain;
+    void * handle;
+    uint64_t size;
+};
+SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor(SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor }, 
+    handle(std::move(init.handle)), 
+    size(std::move(init.size)){}
 
-SharedBufferMemoryDescriptor::operator const WGPUSharedBufferMemoryDescriptor&() const noexcept {
-    return *reinterpret_cast<const WGPUSharedBufferMemoryDescriptor*>(this);
+SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::operator const WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor&() const noexcept {
+    return *reinterpret_cast<const WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor*>(this);
 }
 
-static_assert(sizeof(SharedBufferMemoryDescriptor) == sizeof(WGPUSharedBufferMemoryDescriptor), "sizeof mismatch for SharedBufferMemoryDescriptor");
-static_assert(alignof(SharedBufferMemoryDescriptor) == alignof(WGPUSharedBufferMemoryDescriptor), "alignof mismatch for SharedBufferMemoryDescriptor");
-static_assert(offsetof(SharedBufferMemoryDescriptor, nextInChain) == offsetof(WGPUSharedBufferMemoryDescriptor, nextInChain),
-        "offsetof mismatch for SharedBufferMemoryDescriptor::nextInChain");
-static_assert(offsetof(SharedBufferMemoryDescriptor, label) == offsetof(WGPUSharedBufferMemoryDescriptor, label),
-        "offsetof mismatch for SharedBufferMemoryDescriptor::label");
+static_assert(sizeof(SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor) == sizeof(WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor), "sizeof mismatch for SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor");
+static_assert(alignof(SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor) == alignof(WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor), "alignof mismatch for SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor");
+static_assert(offsetof(SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor, handle) == offsetof(WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor, handle),
+        "offsetof mismatch for SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::handle");
+static_assert(offsetof(SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor, size) == offsetof(WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor, size),
+        "offsetof mismatch for SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::size");
 
 // SharedBufferMemoryEndAccessState implementation
 SharedBufferMemoryEndAccessState::SharedBufferMemoryEndAccessState() = default;
@@ -5909,12 +5966,10 @@ SharedTextureMemoryAHardwareBufferDescriptor::SharedTextureMemoryAHardwareBuffer
 struct SharedTextureMemoryAHardwareBufferDescriptor::Init {
     ChainedStruct * const nextInChain;
     void * handle;
-    Bool useExternalFormat;
 };
 SharedTextureMemoryAHardwareBufferDescriptor::SharedTextureMemoryAHardwareBufferDescriptor(SharedTextureMemoryAHardwareBufferDescriptor::Init&& init)
   : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryAHardwareBufferDescriptor }, 
-    handle(std::move(init.handle)), 
-    useExternalFormat(std::move(init.useExternalFormat)){}
+    handle(std::move(init.handle)){}
 
 SharedTextureMemoryAHardwareBufferDescriptor::operator const WGPUSharedTextureMemoryAHardwareBufferDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryAHardwareBufferDescriptor*>(this);
@@ -5924,8 +5979,6 @@ static_assert(sizeof(SharedTextureMemoryAHardwareBufferDescriptor) == sizeof(WGP
 static_assert(alignof(SharedTextureMemoryAHardwareBufferDescriptor) == alignof(WGPUSharedTextureMemoryAHardwareBufferDescriptor), "alignof mismatch for SharedTextureMemoryAHardwareBufferDescriptor");
 static_assert(offsetof(SharedTextureMemoryAHardwareBufferDescriptor, handle) == offsetof(WGPUSharedTextureMemoryAHardwareBufferDescriptor, handle),
         "offsetof mismatch for SharedTextureMemoryAHardwareBufferDescriptor::handle");
-static_assert(offsetof(SharedTextureMemoryAHardwareBufferDescriptor, useExternalFormat) == offsetof(WGPUSharedTextureMemoryAHardwareBufferDescriptor, useExternalFormat),
-        "offsetof mismatch for SharedTextureMemoryAHardwareBufferDescriptor::useExternalFormat");
 
 // SharedTextureMemoryD3D11BeginState implementation
 SharedTextureMemoryD3D11BeginState::SharedTextureMemoryD3D11BeginState()
@@ -6833,25 +6886,25 @@ static_assert(offsetof(TextureBindingLayout, viewDimension) == offsetof(WGPUText
 static_assert(offsetof(TextureBindingLayout, multisampled) == offsetof(WGPUTextureBindingLayout, multisampled),
         "offsetof mismatch for TextureBindingLayout::multisampled");
 
-// TextureBindingViewDimensionDescriptor implementation
-TextureBindingViewDimensionDescriptor::TextureBindingViewDimensionDescriptor()
-  : ChainedStruct { nullptr, SType::TextureBindingViewDimensionDescriptor } {}
-struct TextureBindingViewDimensionDescriptor::Init {
+// TextureBindingViewDimension implementation
+TextureBindingViewDimension::TextureBindingViewDimension()
+  : ChainedStruct { nullptr, SType::TextureBindingViewDimension } {}
+struct TextureBindingViewDimension::Init {
     ChainedStruct * const nextInChain;
     TextureViewDimension textureBindingViewDimension = TextureViewDimension::Undefined;
 };
-TextureBindingViewDimensionDescriptor::TextureBindingViewDimensionDescriptor(TextureBindingViewDimensionDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::TextureBindingViewDimensionDescriptor }, 
+TextureBindingViewDimension::TextureBindingViewDimension(TextureBindingViewDimension::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::TextureBindingViewDimension }, 
     textureBindingViewDimension(std::move(init.textureBindingViewDimension)){}
 
-TextureBindingViewDimensionDescriptor::operator const WGPUTextureBindingViewDimensionDescriptor&() const noexcept {
-    return *reinterpret_cast<const WGPUTextureBindingViewDimensionDescriptor*>(this);
+TextureBindingViewDimension::operator const WGPUTextureBindingViewDimension&() const noexcept {
+    return *reinterpret_cast<const WGPUTextureBindingViewDimension*>(this);
 }
 
-static_assert(sizeof(TextureBindingViewDimensionDescriptor) == sizeof(WGPUTextureBindingViewDimensionDescriptor), "sizeof mismatch for TextureBindingViewDimensionDescriptor");
-static_assert(alignof(TextureBindingViewDimensionDescriptor) == alignof(WGPUTextureBindingViewDimensionDescriptor), "alignof mismatch for TextureBindingViewDimensionDescriptor");
-static_assert(offsetof(TextureBindingViewDimensionDescriptor, textureBindingViewDimension) == offsetof(WGPUTextureBindingViewDimensionDescriptor, textureBindingViewDimension),
-        "offsetof mismatch for TextureBindingViewDimensionDescriptor::textureBindingViewDimension");
+static_assert(sizeof(TextureBindingViewDimension) == sizeof(WGPUTextureBindingViewDimension), "sizeof mismatch for TextureBindingViewDimension");
+static_assert(alignof(TextureBindingViewDimension) == alignof(WGPUTextureBindingViewDimension), "alignof mismatch for TextureBindingViewDimension");
+static_assert(offsetof(TextureBindingViewDimension, textureBindingViewDimension) == offsetof(WGPUTextureBindingViewDimension, textureBindingViewDimension),
+        "offsetof mismatch for TextureBindingViewDimension::textureBindingViewDimension");
 
 // TextureComponentSwizzle implementation
 
@@ -7101,26 +7154,6 @@ static_assert(offsetof(BindGroupEntry, sampler) == offsetof(WGPUBindGroupEntry,
 static_assert(offsetof(BindGroupEntry, textureView) == offsetof(WGPUBindGroupEntry, textureView),
         "offsetof mismatch for BindGroupEntry::textureView");
 
-// BindGroupLayoutDynamicBindingArray implementation
-BindGroupLayoutDynamicBindingArray::BindGroupLayoutDynamicBindingArray()
-  : ChainedStruct { nullptr, SType::BindGroupLayoutDynamicBindingArray } {}
-struct BindGroupLayoutDynamicBindingArray::Init {
-    ChainedStruct * const nextInChain;
-    DynamicBindingArrayLayout dynamicArray = {};
-};
-BindGroupLayoutDynamicBindingArray::BindGroupLayoutDynamicBindingArray(BindGroupLayoutDynamicBindingArray::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::BindGroupLayoutDynamicBindingArray }, 
-    dynamicArray(std::move(init.dynamicArray)){}
-
-BindGroupLayoutDynamicBindingArray::operator const WGPUBindGroupLayoutDynamicBindingArray&() const noexcept {
-    return *reinterpret_cast<const WGPUBindGroupLayoutDynamicBindingArray*>(this);
-}
-
-static_assert(sizeof(BindGroupLayoutDynamicBindingArray) == sizeof(WGPUBindGroupLayoutDynamicBindingArray), "sizeof mismatch for BindGroupLayoutDynamicBindingArray");
-static_assert(alignof(BindGroupLayoutDynamicBindingArray) == alignof(WGPUBindGroupLayoutDynamicBindingArray), "alignof mismatch for BindGroupLayoutDynamicBindingArray");
-static_assert(offsetof(BindGroupLayoutDynamicBindingArray, dynamicArray) == offsetof(WGPUBindGroupLayoutDynamicBindingArray, dynamicArray),
-        "offsetof mismatch for BindGroupLayoutDynamicBindingArray::dynamicArray");
-
 // BindGroupLayoutEntry implementation
 
 BindGroupLayoutEntry::operator const WGPUBindGroupLayoutEntry&() const noexcept {
@@ -7547,6 +7580,30 @@ static_assert(offsetof(RenderPassColorAttachment, storeOp) == offsetof(WGPURende
 static_assert(offsetof(RenderPassColorAttachment, clearValue) == offsetof(WGPURenderPassColorAttachment, clearValue),
         "offsetof mismatch for RenderPassColorAttachment::clearValue");
 
+// RenderPassRenderAreaRect implementation
+RenderPassRenderAreaRect::RenderPassRenderAreaRect()
+  : ChainedStruct { nullptr, SType::RenderPassRenderAreaRect } {}
+struct RenderPassRenderAreaRect::Init {
+    ChainedStruct * const nextInChain;
+    Origin2D origin = {};
+    Extent2D size = {};
+};
+RenderPassRenderAreaRect::RenderPassRenderAreaRect(RenderPassRenderAreaRect::Init&& init)
+  : ChainedStruct { init.nextInChain, SType::RenderPassRenderAreaRect }, 
+    origin(std::move(init.origin)), 
+    size(std::move(init.size)){}
+
+RenderPassRenderAreaRect::operator const WGPURenderPassRenderAreaRect&() const noexcept {
+    return *reinterpret_cast<const WGPURenderPassRenderAreaRect*>(this);
+}
+
+static_assert(sizeof(RenderPassRenderAreaRect) == sizeof(WGPURenderPassRenderAreaRect), "sizeof mismatch for RenderPassRenderAreaRect");
+static_assert(alignof(RenderPassRenderAreaRect) == alignof(WGPURenderPassRenderAreaRect), "alignof mismatch for RenderPassRenderAreaRect");
+static_assert(offsetof(RenderPassRenderAreaRect, origin) == offsetof(WGPURenderPassRenderAreaRect, origin),
+        "offsetof mismatch for RenderPassRenderAreaRect::origin");
+static_assert(offsetof(RenderPassRenderAreaRect, size) == offsetof(WGPURenderPassRenderAreaRect, size),
+        "offsetof mismatch for RenderPassRenderAreaRect::size");
+
 // RenderPassStorageAttachment implementation
 
 RenderPassStorageAttachment::operator const WGPURenderPassStorageAttachment&() const noexcept {
@@ -7635,6 +7692,19 @@ static_assert(offsetof(ShaderModuleDescriptor, nextInChain) == offsetof(WGPUShad
 static_assert(offsetof(ShaderModuleDescriptor, label) == offsetof(WGPUShaderModuleDescriptor, label),
         "offsetof mismatch for ShaderModuleDescriptor::label");
 
+// SharedBufferMemoryDescriptor implementation
+
+SharedBufferMemoryDescriptor::operator const WGPUSharedBufferMemoryDescriptor&() const noexcept {
+    return *reinterpret_cast<const WGPUSharedBufferMemoryDescriptor*>(this);
+}
+
+static_assert(sizeof(SharedBufferMemoryDescriptor) == sizeof(WGPUSharedBufferMemoryDescriptor), "sizeof mismatch for SharedBufferMemoryDescriptor");
+static_assert(alignof(SharedBufferMemoryDescriptor) == alignof(WGPUSharedBufferMemoryDescriptor), "alignof mismatch for SharedBufferMemoryDescriptor");
+static_assert(offsetof(SharedBufferMemoryDescriptor, nextInChain) == offsetof(WGPUSharedBufferMemoryDescriptor, nextInChain),
+        "offsetof mismatch for SharedBufferMemoryDescriptor::nextInChain");
+static_assert(offsetof(SharedBufferMemoryDescriptor, label) == offsetof(WGPUSharedBufferMemoryDescriptor, label),
+        "offsetof mismatch for SharedBufferMemoryDescriptor::label");
+
 // SharedFenceDescriptor implementation
 
 SharedFenceDescriptor::operator const WGPUSharedFenceDescriptor&() const noexcept {
@@ -8551,9 +8621,6 @@ static_assert(alignof(Adapter) == alignof(WGPUAdapter), "alignof mismatch for Ad
 
 // BindGroup implementation
 
-void BindGroup::Destroy() const {
-    wgpuBindGroupDestroy(Get());
-}
 void BindGroup::SetLabel(StringView label) const {
     wgpuBindGroupSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
 }
@@ -8799,56 +8866,6 @@ void CommandEncoder::WGPURelease(WGPUCommandEncoder handle) {
 static_assert(sizeof(CommandEncoder) == sizeof(WGPUCommandEncoder), "sizeof mismatch for CommandEncoder");
 static_assert(alignof(CommandEncoder) == alignof(WGPUCommandEncoder), "alignof mismatch for CommandEncoder");
 
-// ComputePassEncoder implementation
-
-void ComputePassEncoder::DispatchWorkgroups(uint32_t workgroupCountX, uint32_t workgroupCountY, uint32_t workgroupCountZ) const {
-    wgpuComputePassEncoderDispatchWorkgroups(Get(), workgroupCountX, workgroupCountY, workgroupCountZ);
-}
-void ComputePassEncoder::DispatchWorkgroupsIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const {
-    wgpuComputePassEncoderDispatchWorkgroupsIndirect(Get(), indirectBuffer.Get(), indirectOffset);
-}
-void ComputePassEncoder::End() const {
-    wgpuComputePassEncoderEnd(Get());
-}
-void ComputePassEncoder::InsertDebugMarker(StringView markerLabel) const {
-    wgpuComputePassEncoderInsertDebugMarker(Get(), *reinterpret_cast<WGPUStringView const*>(&markerLabel));
-}
-void ComputePassEncoder::PopDebugGroup() const {
-    wgpuComputePassEncoderPopDebugGroup(Get());
-}
-void ComputePassEncoder::PushDebugGroup(StringView groupLabel) const {
-    wgpuComputePassEncoderPushDebugGroup(Get(), *reinterpret_cast<WGPUStringView const*>(&groupLabel));
-}
-void ComputePassEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const {
-    wgpuComputePassEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const *>(dynamicOffsets));
-}
-void ComputePassEncoder::SetImmediateData(uint32_t offset, void const * data, size_t size) const {
-    wgpuComputePassEncoderSetImmediateData(Get(), offset, reinterpret_cast<void const *>(data), size);
-}
-void ComputePassEncoder::SetLabel(StringView label) const {
-    wgpuComputePassEncoderSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
-}
-void ComputePassEncoder::SetPipeline(ComputePipeline const& pipeline) const {
-    wgpuComputePassEncoderSetPipeline(Get(), pipeline.Get());
-}
-void ComputePassEncoder::WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const {
-    wgpuComputePassEncoderWriteTimestamp(Get(), querySet.Get(), queryIndex);
-}
-
-
-void ComputePassEncoder::WGPUAddRef(WGPUComputePassEncoder handle) {
-    if (handle != nullptr) {
-        wgpuComputePassEncoderAddRef(handle);
-    }
-}
-void ComputePassEncoder::WGPURelease(WGPUComputePassEncoder handle) {
-    if (handle != nullptr) {
-        wgpuComputePassEncoderRelease(handle);
-    }
-}
-static_assert(sizeof(ComputePassEncoder) == sizeof(WGPUComputePassEncoder), "sizeof mismatch for ComputePassEncoder");
-static_assert(alignof(ComputePassEncoder) == alignof(WGPUComputePassEncoder), "alignof mismatch for ComputePassEncoder");
-
 // ComputePipeline implementation
 
 BindGroupLayout ComputePipeline::GetBindGroupLayout(uint32_t groupIndex) const {
@@ -9053,6 +9070,10 @@ Future Device::CreateRenderPipelineAsync(RenderPipelineDescriptor const * descri
             result.id
         };
 }
+ResourceTable Device::CreateResourceTable(ResourceTableDescriptor const * descriptor) const {
+    auto result = wgpuDeviceCreateResourceTable(Get(), reinterpret_cast<WGPUResourceTableDescriptor const *>(descriptor));
+    return ResourceTable::Acquire(result);
+}
 Sampler Device::CreateSampler(SamplerDescriptor const * descriptor) const {
     auto result = wgpuDeviceCreateSampler(Get(), reinterpret_cast<WGPUSamplerDescriptor const *>(descriptor));
     return Sampler::Acquire(result);
@@ -9559,198 +9580,82 @@ void RenderBundle::WGPURelease(WGPURenderBundle handle) {
 static_assert(sizeof(RenderBundle) == sizeof(WGPURenderBundle), "sizeof mismatch for RenderBundle");
 static_assert(alignof(RenderBundle) == alignof(WGPURenderBundle), "alignof mismatch for RenderBundle");
 
-// RenderBundleEncoder implementation
+// RenderPipeline implementation
 
-void RenderBundleEncoder::Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const {
-    wgpuRenderBundleEncoderDraw(Get(), vertexCount, instanceCount, firstVertex, firstInstance);
-}
-void RenderBundleEncoder::DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance) const {
-    wgpuRenderBundleEncoderDrawIndexed(Get(), indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
-}
-void RenderBundleEncoder::DrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const {
-    wgpuRenderBundleEncoderDrawIndexedIndirect(Get(), indirectBuffer.Get(), indirectOffset);
-}
-void RenderBundleEncoder::DrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const {
-    wgpuRenderBundleEncoderDrawIndirect(Get(), indirectBuffer.Get(), indirectOffset);
-}
-RenderBundle RenderBundleEncoder::Finish(RenderBundleDescriptor const * descriptor) const {
-    auto result = wgpuRenderBundleEncoderFinish(Get(), reinterpret_cast<WGPURenderBundleDescriptor const *>(descriptor));
-    return RenderBundle::Acquire(result);
-}
-void RenderBundleEncoder::InsertDebugMarker(StringView markerLabel) const {
-    wgpuRenderBundleEncoderInsertDebugMarker(Get(), *reinterpret_cast<WGPUStringView const*>(&markerLabel));
+BindGroupLayout RenderPipeline::GetBindGroupLayout(uint32_t groupIndex) const {
+    auto result = wgpuRenderPipelineGetBindGroupLayout(Get(), groupIndex);
+    return BindGroupLayout::Acquire(result);
 }
-void RenderBundleEncoder::PopDebugGroup() const {
-    wgpuRenderBundleEncoderPopDebugGroup(Get());
+void RenderPipeline::SetLabel(StringView label) const {
+    wgpuRenderPipelineSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
 }
-void RenderBundleEncoder::PushDebugGroup(StringView groupLabel) const {
-    wgpuRenderBundleEncoderPushDebugGroup(Get(), *reinterpret_cast<WGPUStringView const*>(&groupLabel));
+
+
+void RenderPipeline::WGPUAddRef(WGPURenderPipeline handle) {
+    if (handle != nullptr) {
+        wgpuRenderPipelineAddRef(handle);
+    }
 }
-void RenderBundleEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const {
-    wgpuRenderBundleEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const *>(dynamicOffsets));
+void RenderPipeline::WGPURelease(WGPURenderPipeline handle) {
+    if (handle != nullptr) {
+        wgpuRenderPipelineRelease(handle);
+    }
 }
-void RenderBundleEncoder::SetImmediateData(uint32_t offset, void const * data, size_t size) const {
-    wgpuRenderBundleEncoderSetImmediateData(Get(), offset, reinterpret_cast<void const *>(data), size);
+static_assert(sizeof(RenderPipeline) == sizeof(WGPURenderPipeline), "sizeof mismatch for RenderPipeline");
+static_assert(alignof(RenderPipeline) == alignof(WGPURenderPipeline), "alignof mismatch for RenderPipeline");
+
+// ResourceTable implementation
+
+void ResourceTable::Destroy() const {
+    wgpuResourceTableDestroy(Get());
 }
-void RenderBundleEncoder::SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset, uint64_t size) const {
-    wgpuRenderBundleEncoderSetIndexBuffer(Get(), buffer.Get(), static_cast<WGPUIndexFormat>(format), offset, size);
+uint32_t ResourceTable::GetSize() const {
+    auto result = wgpuResourceTableGetSize(Get());
+    return result;
 }
-void RenderBundleEncoder::SetLabel(StringView label) const {
-    wgpuRenderBundleEncoderSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
+uint32_t ResourceTable::InsertBinding(BindingResource const * resource) const {
+    auto result = wgpuResourceTableInsertBinding(Get(), reinterpret_cast<WGPUBindingResource const *>(resource));
+    return result;
 }
-void RenderBundleEncoder::SetPipeline(RenderPipeline const& pipeline) const {
-    wgpuRenderBundleEncoderSetPipeline(Get(), pipeline.Get());
+ConvertibleStatus ResourceTable::RemoveBinding(uint32_t slot) const {
+    auto result = wgpuResourceTableRemoveBinding(Get(), slot);
+    return static_cast<Status>(result);
 }
-void RenderBundleEncoder::SetVertexBuffer(uint32_t slot, Buffer const& buffer, uint64_t offset, uint64_t size) const {
-    wgpuRenderBundleEncoderSetVertexBuffer(Get(), slot, buffer.Get(), offset, size);
+ConvertibleStatus ResourceTable::Update(uint32_t slot, BindingResource const * resource) const {
+    auto result = wgpuResourceTableUpdate(Get(), slot, reinterpret_cast<WGPUBindingResource const *>(resource));
+    return static_cast<Status>(result);
 }
 
 
-void RenderBundleEncoder::WGPUAddRef(WGPURenderBundleEncoder handle) {
+void ResourceTable::WGPUAddRef(WGPUResourceTable handle) {
     if (handle != nullptr) {
-        wgpuRenderBundleEncoderAddRef(handle);
+        wgpuResourceTableAddRef(handle);
     }
 }
-void RenderBundleEncoder::WGPURelease(WGPURenderBundleEncoder handle) {
+void ResourceTable::WGPURelease(WGPUResourceTable handle) {
     if (handle != nullptr) {
-        wgpuRenderBundleEncoderRelease(handle);
+        wgpuResourceTableRelease(handle);
     }
 }
-static_assert(sizeof(RenderBundleEncoder) == sizeof(WGPURenderBundleEncoder), "sizeof mismatch for RenderBundleEncoder");
-static_assert(alignof(RenderBundleEncoder) == alignof(WGPURenderBundleEncoder), "alignof mismatch for RenderBundleEncoder");
+static_assert(sizeof(ResourceTable) == sizeof(WGPUResourceTable), "sizeof mismatch for ResourceTable");
+static_assert(alignof(ResourceTable) == alignof(WGPUResourceTable), "alignof mismatch for ResourceTable");
 
-// RenderPassEncoder implementation
+// Sampler implementation
 
-void RenderPassEncoder::BeginOcclusionQuery(uint32_t queryIndex) const {
-    wgpuRenderPassEncoderBeginOcclusionQuery(Get(), queryIndex);
-}
-void RenderPassEncoder::Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const {
-    wgpuRenderPassEncoderDraw(Get(), vertexCount, instanceCount, firstVertex, firstInstance);
-}
-void RenderPassEncoder::DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance) const {
-    wgpuRenderPassEncoderDrawIndexed(Get(), indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
-}
-void RenderPassEncoder::DrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const {
-    wgpuRenderPassEncoderDrawIndexedIndirect(Get(), indirectBuffer.Get(), indirectOffset);
-}
-void RenderPassEncoder::DrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const {
-    wgpuRenderPassEncoderDrawIndirect(Get(), indirectBuffer.Get(), indirectOffset);
-}
-void RenderPassEncoder::End() const {
-    wgpuRenderPassEncoderEnd(Get());
-}
-void RenderPassEncoder::EndOcclusionQuery() const {
-    wgpuRenderPassEncoderEndOcclusionQuery(Get());
+void Sampler::SetLabel(StringView label) const {
+    wgpuSamplerSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
 }
-void RenderPassEncoder::ExecuteBundles(size_t bundleCount, RenderBundle const * bundles) const {
-    wgpuRenderPassEncoderExecuteBundles(Get(), bundleCount, reinterpret_cast<WGPURenderBundle const *>(bundles));
+
+
+void Sampler::WGPUAddRef(WGPUSampler handle) {
+    if (handle != nullptr) {
+        wgpuSamplerAddRef(handle);
+    }
 }
-void RenderPassEncoder::InsertDebugMarker(StringView markerLabel) const {
-    wgpuRenderPassEncoderInsertDebugMarker(Get(), *reinterpret_cast<WGPUStringView const*>(&markerLabel));
-}
-void RenderPassEncoder::MultiDrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset, uint32_t maxDrawCount, Buffer const& drawCountBuffer, uint64_t drawCountBufferOffset) const {
-    wgpuRenderPassEncoderMultiDrawIndexedIndirect(Get(), indirectBuffer.Get(), indirectOffset, maxDrawCount, drawCountBuffer.Get(), drawCountBufferOffset);
-}
-void RenderPassEncoder::MultiDrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset, uint32_t maxDrawCount, Buffer const& drawCountBuffer, uint64_t drawCountBufferOffset) const {
-    wgpuRenderPassEncoderMultiDrawIndirect(Get(), indirectBuffer.Get(), indirectOffset, maxDrawCount, drawCountBuffer.Get(), drawCountBufferOffset);
-}
-void RenderPassEncoder::PixelLocalStorageBarrier() const {
-    wgpuRenderPassEncoderPixelLocalStorageBarrier(Get());
-}
-void RenderPassEncoder::PopDebugGroup() const {
-    wgpuRenderPassEncoderPopDebugGroup(Get());
-}
-void RenderPassEncoder::PushDebugGroup(StringView groupLabel) const {
-    wgpuRenderPassEncoderPushDebugGroup(Get(), *reinterpret_cast<WGPUStringView const*>(&groupLabel));
-}
-void RenderPassEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const {
-    wgpuRenderPassEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const *>(dynamicOffsets));
-}
-void RenderPassEncoder::SetBlendConstant(Color const * color) const {
-    wgpuRenderPassEncoderSetBlendConstant(Get(), reinterpret_cast<WGPUColor const *>(color));
-}
-void RenderPassEncoder::SetImmediateData(uint32_t offset, void const * data, size_t size) const {
-    wgpuRenderPassEncoderSetImmediateData(Get(), offset, reinterpret_cast<void const *>(data), size);
-}
-void RenderPassEncoder::SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset, uint64_t size) const {
-    wgpuRenderPassEncoderSetIndexBuffer(Get(), buffer.Get(), static_cast<WGPUIndexFormat>(format), offset, size);
-}
-void RenderPassEncoder::SetLabel(StringView label) const {
-    wgpuRenderPassEncoderSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
-}
-void RenderPassEncoder::SetPipeline(RenderPipeline const& pipeline) const {
-    wgpuRenderPassEncoderSetPipeline(Get(), pipeline.Get());
-}
-void RenderPassEncoder::SetScissorRect(uint32_t x, uint32_t y, uint32_t width, uint32_t height) const {
-    wgpuRenderPassEncoderSetScissorRect(Get(), x, y, width, height);
-}
-void RenderPassEncoder::SetStencilReference(uint32_t reference) const {
-    wgpuRenderPassEncoderSetStencilReference(Get(), reference);
-}
-void RenderPassEncoder::SetVertexBuffer(uint32_t slot, Buffer const& buffer, uint64_t offset, uint64_t size) const {
-    wgpuRenderPassEncoderSetVertexBuffer(Get(), slot, buffer.Get(), offset, size);
-}
-void RenderPassEncoder::SetViewport(float x, float y, float width, float height, float minDepth, float maxDepth) const {
-    wgpuRenderPassEncoderSetViewport(Get(), x, y, width, height, minDepth, maxDepth);
-}
-void RenderPassEncoder::WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const {
-    wgpuRenderPassEncoderWriteTimestamp(Get(), querySet.Get(), queryIndex);
-}
-
-
-void RenderPassEncoder::WGPUAddRef(WGPURenderPassEncoder handle) {
-    if (handle != nullptr) {
-        wgpuRenderPassEncoderAddRef(handle);
-    }
-}
-void RenderPassEncoder::WGPURelease(WGPURenderPassEncoder handle) {
-    if (handle != nullptr) {
-        wgpuRenderPassEncoderRelease(handle);
-    }
-}
-static_assert(sizeof(RenderPassEncoder) == sizeof(WGPURenderPassEncoder), "sizeof mismatch for RenderPassEncoder");
-static_assert(alignof(RenderPassEncoder) == alignof(WGPURenderPassEncoder), "alignof mismatch for RenderPassEncoder");
-
-// RenderPipeline implementation
-
-BindGroupLayout RenderPipeline::GetBindGroupLayout(uint32_t groupIndex) const {
-    auto result = wgpuRenderPipelineGetBindGroupLayout(Get(), groupIndex);
-    return BindGroupLayout::Acquire(result);
-}
-void RenderPipeline::SetLabel(StringView label) const {
-    wgpuRenderPipelineSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
-}
-
-
-void RenderPipeline::WGPUAddRef(WGPURenderPipeline handle) {
-    if (handle != nullptr) {
-        wgpuRenderPipelineAddRef(handle);
-    }
-}
-void RenderPipeline::WGPURelease(WGPURenderPipeline handle) {
-    if (handle != nullptr) {
-        wgpuRenderPipelineRelease(handle);
-    }
-}
-static_assert(sizeof(RenderPipeline) == sizeof(WGPURenderPipeline), "sizeof mismatch for RenderPipeline");
-static_assert(alignof(RenderPipeline) == alignof(WGPURenderPipeline), "alignof mismatch for RenderPipeline");
-
-// Sampler implementation
-
-void Sampler::SetLabel(StringView label) const {
-    wgpuSamplerSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
-}
-
-
-void Sampler::WGPUAddRef(WGPUSampler handle) {
-    if (handle != nullptr) {
-        wgpuSamplerAddRef(handle);
-    }
-}
-void Sampler::WGPURelease(WGPUSampler handle) {
-    if (handle != nullptr) {
-        wgpuSamplerRelease(handle);
-    }
+void Sampler::WGPURelease(WGPUSampler handle) {
+    if (handle != nullptr) {
+        wgpuSamplerRelease(handle);
+    }
 }
 static_assert(sizeof(Sampler) == sizeof(WGPUSampler), "sizeof mismatch for Sampler");
 static_assert(alignof(Sampler) == alignof(WGPUSampler), "alignof mismatch for Sampler");
@@ -9876,6 +9781,9 @@ static_assert(alignof(SharedBufferMemory) == alignof(WGPUSharedBufferMemory), "a
 void SharedFence::ExportInfo(SharedFenceExportInfo * info) const {
     wgpuSharedFenceExportInfo(Get(), reinterpret_cast<WGPUSharedFenceExportInfo *>(info));
 }
+void SharedFence::SetLabel(StringView label) const {
+    wgpuSharedFenceSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
+}
 
 
 void SharedFence::WGPUAddRef(WGPUSharedFence handle) {
@@ -10027,6 +9935,10 @@ uint32_t Texture::GetSampleCount() const {
     auto result = wgpuTextureGetSampleCount(Get());
     return result;
 }
+TextureViewDimension Texture::GetTextureBindingViewDimension() const {
+    auto result = wgpuTextureGetTextureBindingViewDimension(Get());
+    return static_cast<TextureViewDimension>(result);
+}
 TextureUsage Texture::GetUsage() const {
     auto result = wgpuTextureGetUsage(Get());
     return static_cast<TextureUsage>(result);
@@ -10041,6 +9953,9 @@ void Texture::Pin(TextureUsage usage) const {
 void Texture::SetLabel(StringView label) const {
     wgpuTextureSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
 }
+void Texture::SetOwnershipForMemoryDump(uint64_t ownerGuid) const {
+    wgpuTextureSetOwnershipForMemoryDump(Get(), ownerGuid);
+}
 void Texture::Unpin() const {
     wgpuTextureUnpin(Get());
 }
@@ -10079,6 +9994,217 @@ void TextureView::WGPURelease(WGPUTextureView handle) {
 static_assert(sizeof(TextureView) == sizeof(WGPUTextureView), "sizeof mismatch for TextureView");
 static_assert(alignof(TextureView) == alignof(WGPUTextureView), "alignof mismatch for TextureView");
 
+// ComputePassEncoder implementation
+
+void ComputePassEncoder::DispatchWorkgroups(uint32_t workgroupCountX, uint32_t workgroupCountY, uint32_t workgroupCountZ) const {
+    wgpuComputePassEncoderDispatchWorkgroups(Get(), workgroupCountX, workgroupCountY, workgroupCountZ);
+}
+void ComputePassEncoder::DispatchWorkgroupsIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const {
+    wgpuComputePassEncoderDispatchWorkgroupsIndirect(Get(), indirectBuffer.Get(), indirectOffset);
+}
+void ComputePassEncoder::End() const {
+    wgpuComputePassEncoderEnd(Get());
+}
+void ComputePassEncoder::InsertDebugMarker(StringView markerLabel) const {
+    wgpuComputePassEncoderInsertDebugMarker(Get(), *reinterpret_cast<WGPUStringView const*>(&markerLabel));
+}
+void ComputePassEncoder::PopDebugGroup() const {
+    wgpuComputePassEncoderPopDebugGroup(Get());
+}
+void ComputePassEncoder::PushDebugGroup(StringView groupLabel) const {
+    wgpuComputePassEncoderPushDebugGroup(Get(), *reinterpret_cast<WGPUStringView const*>(&groupLabel));
+}
+void ComputePassEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const {
+    wgpuComputePassEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const *>(dynamicOffsets));
+}
+void ComputePassEncoder::SetImmediates(uint32_t offset, void const * data, size_t size) const {
+    wgpuComputePassEncoderSetImmediates(Get(), offset, reinterpret_cast<void const *>(data), size);
+}
+void ComputePassEncoder::SetLabel(StringView label) const {
+    wgpuComputePassEncoderSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
+}
+void ComputePassEncoder::SetPipeline(ComputePipeline const& pipeline) const {
+    wgpuComputePassEncoderSetPipeline(Get(), pipeline.Get());
+}
+void ComputePassEncoder::SetResourceTable(ResourceTable const& table) const {
+    wgpuComputePassEncoderSetResourceTable(Get(), table.Get());
+}
+void ComputePassEncoder::WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const {
+    wgpuComputePassEncoderWriteTimestamp(Get(), querySet.Get(), queryIndex);
+}
+
+
+void ComputePassEncoder::WGPUAddRef(WGPUComputePassEncoder handle) {
+    if (handle != nullptr) {
+        wgpuComputePassEncoderAddRef(handle);
+    }
+}
+void ComputePassEncoder::WGPURelease(WGPUComputePassEncoder handle) {
+    if (handle != nullptr) {
+        wgpuComputePassEncoderRelease(handle);
+    }
+}
+static_assert(sizeof(ComputePassEncoder) == sizeof(WGPUComputePassEncoder), "sizeof mismatch for ComputePassEncoder");
+static_assert(alignof(ComputePassEncoder) == alignof(WGPUComputePassEncoder), "alignof mismatch for ComputePassEncoder");
+
+// RenderBundleEncoder implementation
+
+void RenderBundleEncoder::Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const {
+    wgpuRenderBundleEncoderDraw(Get(), vertexCount, instanceCount, firstVertex, firstInstance);
+}
+void RenderBundleEncoder::DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance) const {
+    wgpuRenderBundleEncoderDrawIndexed(Get(), indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
+}
+void RenderBundleEncoder::DrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const {
+    wgpuRenderBundleEncoderDrawIndexedIndirect(Get(), indirectBuffer.Get(), indirectOffset);
+}
+void RenderBundleEncoder::DrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const {
+    wgpuRenderBundleEncoderDrawIndirect(Get(), indirectBuffer.Get(), indirectOffset);
+}
+RenderBundle RenderBundleEncoder::Finish(RenderBundleDescriptor const * descriptor) const {
+    auto result = wgpuRenderBundleEncoderFinish(Get(), reinterpret_cast<WGPURenderBundleDescriptor const *>(descriptor));
+    return RenderBundle::Acquire(result);
+}
+void RenderBundleEncoder::InsertDebugMarker(StringView markerLabel) const {
+    wgpuRenderBundleEncoderInsertDebugMarker(Get(), *reinterpret_cast<WGPUStringView const*>(&markerLabel));
+}
+void RenderBundleEncoder::PopDebugGroup() const {
+    wgpuRenderBundleEncoderPopDebugGroup(Get());
+}
+void RenderBundleEncoder::PushDebugGroup(StringView groupLabel) const {
+    wgpuRenderBundleEncoderPushDebugGroup(Get(), *reinterpret_cast<WGPUStringView const*>(&groupLabel));
+}
+void RenderBundleEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const {
+    wgpuRenderBundleEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const *>(dynamicOffsets));
+}
+void RenderBundleEncoder::SetImmediates(uint32_t offset, void const * data, size_t size) const {
+    wgpuRenderBundleEncoderSetImmediates(Get(), offset, reinterpret_cast<void const *>(data), size);
+}
+void RenderBundleEncoder::SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset, uint64_t size) const {
+    wgpuRenderBundleEncoderSetIndexBuffer(Get(), buffer.Get(), static_cast<WGPUIndexFormat>(format), offset, size);
+}
+void RenderBundleEncoder::SetLabel(StringView label) const {
+    wgpuRenderBundleEncoderSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
+}
+void RenderBundleEncoder::SetPipeline(RenderPipeline const& pipeline) const {
+    wgpuRenderBundleEncoderSetPipeline(Get(), pipeline.Get());
+}
+void RenderBundleEncoder::SetResourceTable(ResourceTable const& table) const {
+    wgpuRenderBundleEncoderSetResourceTable(Get(), table.Get());
+}
+void RenderBundleEncoder::SetVertexBuffer(uint32_t slot, Buffer const& buffer, uint64_t offset, uint64_t size) const {
+    wgpuRenderBundleEncoderSetVertexBuffer(Get(), slot, buffer.Get(), offset, size);
+}
+
+
+void RenderBundleEncoder::WGPUAddRef(WGPURenderBundleEncoder handle) {
+    if (handle != nullptr) {
+        wgpuRenderBundleEncoderAddRef(handle);
+    }
+}
+void RenderBundleEncoder::WGPURelease(WGPURenderBundleEncoder handle) {
+    if (handle != nullptr) {
+        wgpuRenderBundleEncoderRelease(handle);
+    }
+}
+static_assert(sizeof(RenderBundleEncoder) == sizeof(WGPURenderBundleEncoder), "sizeof mismatch for RenderBundleEncoder");
+static_assert(alignof(RenderBundleEncoder) == alignof(WGPURenderBundleEncoder), "alignof mismatch for RenderBundleEncoder");
+
+// RenderPassEncoder implementation
+
+void RenderPassEncoder::BeginOcclusionQuery(uint32_t queryIndex) const {
+    wgpuRenderPassEncoderBeginOcclusionQuery(Get(), queryIndex);
+}
+void RenderPassEncoder::Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const {
+    wgpuRenderPassEncoderDraw(Get(), vertexCount, instanceCount, firstVertex, firstInstance);
+}
+void RenderPassEncoder::DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance) const {
+    wgpuRenderPassEncoderDrawIndexed(Get(), indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
+}
+void RenderPassEncoder::DrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const {
+    wgpuRenderPassEncoderDrawIndexedIndirect(Get(), indirectBuffer.Get(), indirectOffset);
+}
+void RenderPassEncoder::DrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const {
+    wgpuRenderPassEncoderDrawIndirect(Get(), indirectBuffer.Get(), indirectOffset);
+}
+void RenderPassEncoder::End() const {
+    wgpuRenderPassEncoderEnd(Get());
+}
+void RenderPassEncoder::EndOcclusionQuery() const {
+    wgpuRenderPassEncoderEndOcclusionQuery(Get());
+}
+void RenderPassEncoder::ExecuteBundles(size_t bundleCount, RenderBundle const * bundles) const {
+    wgpuRenderPassEncoderExecuteBundles(Get(), bundleCount, reinterpret_cast<WGPURenderBundle const *>(bundles));
+}
+void RenderPassEncoder::InsertDebugMarker(StringView markerLabel) const {
+    wgpuRenderPassEncoderInsertDebugMarker(Get(), *reinterpret_cast<WGPUStringView const*>(&markerLabel));
+}
+void RenderPassEncoder::MultiDrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset, uint32_t maxDrawCount, Buffer const& drawCountBuffer, uint64_t drawCountBufferOffset) const {
+    wgpuRenderPassEncoderMultiDrawIndexedIndirect(Get(), indirectBuffer.Get(), indirectOffset, maxDrawCount, drawCountBuffer.Get(), drawCountBufferOffset);
+}
+void RenderPassEncoder::MultiDrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset, uint32_t maxDrawCount, Buffer const& drawCountBuffer, uint64_t drawCountBufferOffset) const {
+    wgpuRenderPassEncoderMultiDrawIndirect(Get(), indirectBuffer.Get(), indirectOffset, maxDrawCount, drawCountBuffer.Get(), drawCountBufferOffset);
+}
+void RenderPassEncoder::PixelLocalStorageBarrier() const {
+    wgpuRenderPassEncoderPixelLocalStorageBarrier(Get());
+}
+void RenderPassEncoder::PopDebugGroup() const {
+    wgpuRenderPassEncoderPopDebugGroup(Get());
+}
+void RenderPassEncoder::PushDebugGroup(StringView groupLabel) const {
+    wgpuRenderPassEncoderPushDebugGroup(Get(), *reinterpret_cast<WGPUStringView const*>(&groupLabel));
+}
+void RenderPassEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const {
+    wgpuRenderPassEncoderSetBindGroup(Get(), groupIndex, group.Get(), dynamicOffsetCount, reinterpret_cast<uint32_t const *>(dynamicOffsets));
+}
+void RenderPassEncoder::SetBlendConstant(Color const * color) const {
+    wgpuRenderPassEncoderSetBlendConstant(Get(), reinterpret_cast<WGPUColor const *>(color));
+}
+void RenderPassEncoder::SetImmediates(uint32_t offset, void const * data, size_t size) const {
+    wgpuRenderPassEncoderSetImmediates(Get(), offset, reinterpret_cast<void const *>(data), size);
+}
+void RenderPassEncoder::SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset, uint64_t size) const {
+    wgpuRenderPassEncoderSetIndexBuffer(Get(), buffer.Get(), static_cast<WGPUIndexFormat>(format), offset, size);
+}
+void RenderPassEncoder::SetLabel(StringView label) const {
+    wgpuRenderPassEncoderSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
+}
+void RenderPassEncoder::SetPipeline(RenderPipeline const& pipeline) const {
+    wgpuRenderPassEncoderSetPipeline(Get(), pipeline.Get());
+}
+void RenderPassEncoder::SetResourceTable(ResourceTable const& table) const {
+    wgpuRenderPassEncoderSetResourceTable(Get(), table.Get());
+}
+void RenderPassEncoder::SetScissorRect(uint32_t x, uint32_t y, uint32_t width, uint32_t height) const {
+    wgpuRenderPassEncoderSetScissorRect(Get(), x, y, width, height);
+}
+void RenderPassEncoder::SetStencilReference(uint32_t reference) const {
+    wgpuRenderPassEncoderSetStencilReference(Get(), reference);
+}
+void RenderPassEncoder::SetVertexBuffer(uint32_t slot, Buffer const& buffer, uint64_t offset, uint64_t size) const {
+    wgpuRenderPassEncoderSetVertexBuffer(Get(), slot, buffer.Get(), offset, size);
+}
+void RenderPassEncoder::SetViewport(float x, float y, float width, float height, float minDepth, float maxDepth) const {
+    wgpuRenderPassEncoderSetViewport(Get(), x, y, width, height, minDepth, maxDepth);
+}
+void RenderPassEncoder::WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const {
+    wgpuRenderPassEncoderWriteTimestamp(Get(), querySet.Get(), queryIndex);
+}
+
+
+void RenderPassEncoder::WGPUAddRef(WGPURenderPassEncoder handle) {
+    if (handle != nullptr) {
+        wgpuRenderPassEncoderAddRef(handle);
+    }
+}
+void RenderPassEncoder::WGPURelease(WGPURenderPassEncoder handle) {
+    if (handle != nullptr) {
+        wgpuRenderPassEncoderRelease(handle);
+    }
+}
+static_assert(sizeof(RenderPassEncoder) == sizeof(WGPURenderPassEncoder), "sizeof mismatch for RenderPassEncoder");
+static_assert(alignof(RenderPassEncoder) == alignof(WGPURenderPassEncoder), "alignof mismatch for RenderPassEncoder");
+