Merge branch 'odin-lang:master' into master

src/check_expr.cpp

@@ -8161,7 +8161,10 @@ ExprKind check_compound_literal(CheckerContext *c, Operand *o, Ast *node, Type *
 	case Type_Basic: {
 		if (!is_type_any(t)) {
 			if (cl->elems.count != 0) {
-				error(node, "Illegal compound literal");
+				gbString s = type_to_string(t);
+				error(node, "Illegal compound literal, %s cannot be used as a compound literal with fields", s);
+				gb_string_free(s);
+				is_constant = false;
 			}
 			break;
 		}

src/exact_value.cpp

@@ -591,6 +591,7 @@ failure:
 i32 exact_value_order(ExactValue const &v) {
 	switch (v.kind) {
 	case ExactValue_Invalid:
+	case ExactValue_Compound:
 		return 0;
 	case ExactValue_Bool:
 	case ExactValue_String:
@@ -607,8 +608,6 @@ i32 exact_value_order(ExactValue const &v) {
 		return 6;
 	case ExactValue_Procedure:
 		return 7;
-	// case ExactValue_Compound:
-		// return 8;
 
 	default:
 		GB_PANIC("How'd you get here? Invalid Value.kind %d", v.kind);

vendor/darwin/Foundation/NSApplication.odin

@@ -0,0 +1,95 @@
+package objc_Foundation
+
+import "core:intrinsics"
+
+ActivationPolicy :: enum UInteger {
+	Regular    = 0,
+	Accessory  = 1,
+	Prohibited = 2,
+}
+
+ApplicationDelegate :: struct {
+	willFinishLaunching:                  proc "c" (self: ^ApplicationDelegate, notification: ^Notification),
+	didFinishLaunching:                   proc "c" (self: ^ApplicationDelegate, notification: ^Notification),
+	shouldTerminateAfterLastWindowClosed: proc "c" (self: ^ApplicationDelegate, sender: ^Application),
+
+	user_data: rawptr,
+}
+
+@(objc_class="NSApplication")
+Application :: struct {using _: Object}
+
+@(objc_type=Application, objc_name="sharedApplication", objc_is_class_method=true)
+Application_sharedApplication :: proc() -> ^Application {
+	return msgSend(^Application, Application, "sharedApplication")
+}
+
+@(objc_type=Application, objc_name="setDelegate")
+Application_setDelegate :: proc(self: ^Application, delegate: ^ApplicationDelegate) {
+	willFinishLaunching :: proc "c" (self: ^Value, _: SEL, notification: ^Notification) {
+		del := (^ApplicationDelegate)(self->pointerValue())
+		del->willFinishLaunching(notification)
+	}
+	didFinishLaunching :: proc "c" (self: ^Value, _: SEL, notification: ^Notification) {
+		del := (^ApplicationDelegate)(self->pointerValue())
+		del->didFinishLaunching(notification)
+	}
+	shouldTerminateAfterLastWindowClosed :: proc "c" (self: ^Value, _: SEL, application: ^Application) {
+		del := (^ApplicationDelegate)(self->pointerValue())
+		del->shouldTerminateAfterLastWindowClosed(application)
+	}
+
+	wrapper := Value.valueWithPointer(delegate)
+
+	class_addMethod(intrinsics.objc_find_class("NSValue"), intrinsics.objc_find_selector("applicationWillFinishLaunching:"),                  auto_cast willFinishLaunching,                  "v@:@")
+	class_addMethod(intrinsics.objc_find_class("NSValue"), intrinsics.objc_find_selector("applicationDidFinishLaunching:"),                   auto_cast didFinishLaunching,                   "v@:@")
+	class_addMethod(intrinsics.objc_find_class("NSValue"), intrinsics.objc_find_selector("applicationShouldTerminateAfterLastWindowClosed:"), auto_cast shouldTerminateAfterLastWindowClosed, "B@:@")
+
+	msgSend(nil, self, "setDelegate:", wrapper)
+}
+
+@(objc_type=Application, objc_name="setActivationPolicy")
+Application_setActivationPolicy :: proc(self: ^Application, activationPolicy: ActivationPolicy) -> BOOL {
+	return msgSend(BOOL, self, "setActivationPolicy:", activationPolicy)
+}
+
+@(objc_type=Application, objc_name="activateIgnoringOtherApps")
+Application_activateIgnoringOtherApps :: proc(self: ^Application, ignoreOtherApps: BOOL) {
+	msgSend(nil, self, "activateIgnoringOtherApps:", ignoreOtherApps)
+}
+
+@(objc_type=Application, objc_name="setMainMenu")
+Application_setMainMenu :: proc(self: ^Application, menu: ^Menu) {
+	msgSend(nil, self, "setMainMenu:", menu)
+}
+
+@(objc_type=Application, objc_name="windows")
+Application_windows :: proc(self: ^Application) -> ^Array {
+	return msgSend(^Array, self, "windows")
+}
+
+@(objc_type=Application, objc_name="run")
+Application_run :: proc(self: ^Application) {
+	msgSend(nil, self, "run")
+}
+
+
+@(objc_type=Application, objc_name="terminate")
+Application_terminate :: proc(self: ^Application, sender: ^Object) {
+	msgSend(nil, self, "terminate:", sender)
+}
+
+
+
+@(objc_class="NSRunningApplication")
+RunningApplication :: struct {using _: Object}
+
+@(objc_type=RunningApplication, objc_name="currentApplication", objc_is_class_method=true)
+RunningApplication_currentApplication :: proc() -> ^RunningApplication {
+	return msgSend(^RunningApplication, RunningApplication, "currentApplication")
+}
+
+@(objc_type=RunningApplication, objc_name="localizedName")
+RunningApplication_localizedName :: proc(self: ^RunningApplication) -> ^String {
+	return msgSend(^String, self, "localizedName")
+}

vendor/darwin/Foundation/NSBlock.odin

@@ -0,0 +1,81 @@
+package objc_Foundation
+
+import "core:intrinsics"
+
+@(objc_class="NSConcreteGlobalBlock")
+Block :: struct {using _: Object}
+
+@(objc_type=Block, objc_name="createGlobal", objc_is_class_method=true)
+Block_createGlobal :: proc "c" (user_data: rawptr, user_proc: proc "c" (user_data: rawptr)) -> ^Block {
+	return Block_createInternal(true, user_data, user_proc)
+}
+
+@(objc_type=Block, objc_name="createLocal", objc_is_class_method=true)
+Block_createLocal :: proc "c" (user_data: rawptr, user_proc: proc "c" (user_data: rawptr)) -> ^Block {
+	return Block_createInternal(false, user_data, user_proc)
+}
+
+
+@(private)
+Internal_Block_Literal_Base :: struct {
+	isa:        ^intrinsics.objc_class,
+	flags:      u32,
+	reserved:   u32,
+	invoke:     proc "c" (^Internal_Block_Literal),
+	descriptor: ^Block_Descriptor,
+}
+
+@(private)
+Internal_Block_Literal :: struct {
+	using base: Internal_Block_Literal_Base,
+	// Imported Variables
+	user_proc:  proc "c" (user_data: rawptr),
+	user_data:  rawptr,
+}
+
+@(private)
+Block_Descriptor :: struct {
+	reserved:       uint,
+	size:           uint,
+	copy_helper:    proc "c" (dst, src: rawptr),
+	dispose_helper: proc "c" (src: rawptr),
+	signature:      cstring,
+}
+
+@(private)
+global_block_descriptor := Block_Descriptor{
+	reserved = 0,
+	size     = size_of(Internal_Block_Literal),
+}
+
+@(private="file")
+Block_createInternal :: proc "c" (is_global: bool, user_data: rawptr, user_proc: proc "c" (user_data: rawptr)) -> ^Block {
+	// Set to true on blocks that have captures (and thus are not true
+	// global blocks) but are known not to escape for various other
+	// reasons. For backward compatibility with old runtimes, whenever
+	// BLOCK_IS_NOESCAPE is set, BLOCK_IS_GLOBAL is set too. Copying a
+	// non-escaping block returns the original block and releasing such a
+	// block is a no-op, which is exactly how global blocks are handled.
+	BLOCK_IS_NOESCAPE      :: (1 << 23)|BLOCK_IS_GLOBAL
+
+	BLOCK_HAS_COPY_DISPOSE :: 1 << 25
+	BLOCK_HAS_CTOR         :: 1 << 26 // helpers have C++ code
+	BLOCK_IS_GLOBAL        :: 1 << 28
+	BLOCK_HAS_STRET        :: 1 << 29 // IFF BLOCK_HAS_SIGNATURE
+	BLOCK_HAS_SIGNATURE    :: 1 << 30
+
+	extraBytes :: size_of(Internal_Block_Literal) - size_of(Internal_Block_Literal_Base)
+
+	cls := intrinsics.objc_find_class("NSConcreteGlobalBlock")
+	bl := (^Internal_Block_Literal)(AllocateObject(cls, extraBytes, nil))
+	bl.isa = cls
+	bl.flags = BLOCK_IS_GLOBAL if is_global else 0
+	bl.invoke = proc "c" (bl: ^Internal_Block_Literal) {
+		bl.user_proc(bl.user_data)
+	}
+	bl.descriptor = &global_block_descriptor
+	bl.user_proc = user_proc
+	bl.user_data = user_data
+
+	return auto_cast bl
+}

vendor/darwin/Foundation/NSMenu.odin

@@ -0,0 +1,103 @@
+package objc_Foundation
+
+import "core:builtin"
+import "core:intrinsics"
+
+KeyEquivalentModifierFlag :: enum UInteger {
+	CapsLock   = 16, // Set if Caps Lock key is pressed.
+	Shift      = 17, // Set if Shift key is pressed.
+	Control    = 18, // Set if Control key is pressed.
+	Option     = 19, // Set if Option or Alternate key is pressed.
+	Command    = 20, // Set if Command key is pressed.
+	NumericPad = 21, // Set if any key in the numeric keypad is pressed.
+	Help       = 22, // Set if the Help key is pressed.
+	Function   = 23, // Set if any function key is pressed.
+}
+KeyEquivalentModifierMask :: distinct bit_set[KeyEquivalentModifierFlag; UInteger]
+
+// Used to retrieve only the device-independent modifier flags, allowing applications to mask off the device-dependent modifier flags, including event coalescing information.
+KeyEventModifierFlagDeviceIndependentFlagsMask := transmute(KeyEquivalentModifierMask)_KeyEventModifierFlagDeviceIndependentFlagsMask
+@(private) _KeyEventModifierFlagDeviceIndependentFlagsMask := UInteger(0xffff0000)
+
+
+MenuItemCallback :: proc "c" (unused: rawptr, name: SEL, sender: ^Object)
+
+
+@(objc_class="NSMenuItem")
+MenuItem :: struct {using _: Object} 
+
+@(objc_type=MenuItem, objc_name="alloc", objc_is_class_method=true)
+MenuItem_alloc :: proc() -> ^MenuItem {
+	return msgSend(^MenuItem, MenuItem, "alloc")
+}
+@(objc_type=MenuItem, objc_name="registerActionCallback", objc_is_class_method=true)
+MenuItem_registerActionCallback :: proc(name: cstring, callback: MenuItemCallback) -> SEL {
+	s := string(name)
+	n := len(s)
+	sel: SEL
+	if n > 0 && s[n-1] != ':' {
+		col_name := intrinsics.alloca(n+2, 1)
+		builtin.copy(col_name[:n], s)
+		col_name[n] = ':'
+		col_name[n+1] = 0
+		sel = sel_registerName(cstring(col_name))
+	} else {
+		sel = sel_registerName(name)
+	}
+	if callback != nil {
+		class_addMethod(intrinsics.objc_find_class("NSObject"), sel, auto_cast callback, "v@:@")
+	}
+	return sel
+}
+
+@(objc_type=MenuItem, objc_name="init")
+MenuItem_init :: proc(self: ^MenuItem) -> ^MenuItem {
+	return msgSend(^MenuItem, self, "init")
+}
+
+@(objc_type=MenuItem, objc_name="setKeyEquivalentModifierMask")
+MenuItem_setKeyEquivalentModifierMask :: proc(self: ^MenuItem, modifierMask: KeyEquivalentModifierMask) {
+	msgSend(nil, self, "setKeyEquivalentModifierMask:", modifierMask)
+}
+
+@(objc_type=MenuItem, objc_name="keyEquivalentModifierMask")
+MenuItem_keyEquivalentModifierMask :: proc(self: ^MenuItem) -> KeyEquivalentModifierMask {
+	return msgSend(KeyEquivalentModifierMask, self, "keyEquivalentModifierMask")
+}
+
+@(objc_type=MenuItem, objc_name="setSubmenu")
+MenuItem_setSubmenu :: proc(self: ^MenuItem, submenu: ^Menu) {
+	msgSend(nil, self, "setSubmenu:", submenu)
+}
+
+
+
+
+@(objc_class="NSMenu")
+Menu :: struct {using _: Object} 
+
+@(objc_type=Menu, objc_name="alloc", objc_is_class_method=true)
+Menu_alloc :: proc() -> ^Menu {
+	return msgSend(^Menu, Menu, "alloc")
+}
+
+@(objc_type=Menu, objc_name="init")
+Menu_init :: proc(self: ^Menu) -> ^Menu {
+	return msgSend(^Menu, self, "init")
+}
+
+@(objc_type=Menu, objc_name="initWithTitle")
+Menu_initWithTitle :: proc(self: ^Menu, title: ^String) -> ^Menu {
+	return msgSend(^Menu, self, "initWithTitle:", title)
+}
+
+
+@(objc_type=Menu, objc_name="addItem")
+Menu_addItem :: proc(self: ^Menu, item: ^MenuItem) {
+	msgSend(nil, self, "addItem:", item)
+}
+
+@(objc_type=Menu, objc_name="addItemWithTitle")
+Menu_addItemWithTitle :: proc(self: ^Menu, title: ^String, selector: SEL, keyEquivalent: ^String) -> ^MenuItem {
+	return msgSend(^MenuItem, self, "addItemWithTitle:action:keyEquivalent:", title, selector, keyEquivalent)
+}

vendor/darwin/Foundation/NSNumber.odin

@@ -48,17 +48,17 @@ Value_getValue :: proc(self: ^Value, value: rawptr, size: UInteger) {
 
 
 @(objc_type=Value, objc_name="objCType")
-Value_objCType :: proc(self: ^Value) -> cstring {
+Value_objCType :: proc "c" (self: ^Value) -> cstring {
 	return msgSend(cstring, self, "objCType")
 }
 
 @(objc_type=Value, objc_name="isEqualToValue")
-Value_isEqualToValue :: proc(self, other: ^Value) -> BOOL {
+Value_isEqualToValue :: proc "c" (self, other: ^Value) -> BOOL {
 	return msgSend(BOOL, self, "isEqualToValue:", other)
 }
 
 @(objc_type=Value, objc_name="pointerValue")
-Value_pointerValue :: proc(self: ^Value) -> rawptr {
+Value_pointerValue :: proc "c" (self: ^Value) -> rawptr {
 	return msgSend(rawptr, self, "pointerValue")
 }
 

vendor/darwin/Foundation/NSObject.odin

@@ -53,7 +53,10 @@ autorelease :: proc(self: ^Object) {
 retainCount :: proc(self: ^Object) -> UInteger {
 	return msgSend(UInteger, self, "retainCount")
 }
-
+@(objc_type=Object, objc_name="class")
+class :: proc(self: ^Object) -> Class {
+	return msgSend(Class, self, "class")
+}
 
 @(objc_type=Object, objc_name="hash")
 hash :: proc(self: ^Object) -> UInteger {

vendor/darwin/Foundation/NSString.odin

@@ -49,6 +49,10 @@ StringCompareOption :: enum UInteger {
 
 unichar :: distinct u16
 
+@(link_prefix="NS", default_calling_convention="c")
+foreign Foundation {
+	StringFromClass :: proc(cls: Class) -> ^String ---
+}
 
 AT :: MakeConstantString
 MakeConstantString :: proc "c" (#const c: cstring) -> ^String {

vendor/darwin/Foundation/NSTypes.odin

@@ -33,3 +33,10 @@ ComparisonResult :: enum Integer {
 }
 
 NotFound :: IntegerMax
+
+Float :: distinct (f32 when size_of(uint) == 4 else f64)
+
+Size :: struct {
+	width:  Float,
+	height: Float,
+}

vendor/darwin/Foundation/NSWindow.odin

@@ -7,18 +7,75 @@ Rect :: struct {
 	width, height: f64,
 }
 
+WindowStyleFlag :: enum NS.UInteger {
+	Titled                 = 0,
+	Closable               = 1,
+	Miniaturizable         = 2,
+	Resizable              = 3,
+	TexturedBackground     = 8,
+	UnifiedTitleAndToolbar = 12,
+	FullScreen             = 14,
+	FullSizeContentView    = 15,
+	UtilityWindow          = 4,
+	DocModalWindow         = 6,
+	NonactivatingPanel     = 7,
+	HUDWindow              = 13,
+}
+WindowStyleMask :: distinct bit_set[WindowStyleFlag; NS.UInteger]
+WindowStyleMaskBorderless             :: WindowStyleMask{}
+WindowStyleMaskTitled                 :: WindowStyleMask{.Titled}
+WindowStyleMaskClosable               :: WindowStyleMask{.Closable}
+WindowStyleMaskMiniaturizable         :: WindowStyleMask{.Miniaturizable}
+WindowStyleMaskResizable              :: WindowStyleMask{.Resizable}
+WindowStyleMaskTexturedBackground     :: WindowStyleMask{.TexturedBackground}
+WindowStyleMaskUnifiedTitleAndToolbar :: WindowStyleMask{.UnifiedTitleAndToolbar}
+WindowStyleMaskFullScreen             :: WindowStyleMask{.FullScreen}
+WindowStyleMaskFullSizeContentView    :: WindowStyleMask{.FullSizeContentView}
+WindowStyleMaskUtilityWindow          :: WindowStyleMask{.UtilityWindow}
+WindowStyleMaskDocModalWindow         :: WindowStyleMask{.DocModalWindow}
+WindowStyleMaskNonactivatingPanel     :: WindowStyleMask{.NonactivatingPanel}
+WindowStyleMaskHUDWindow              :: WindowStyleMask{.HUDWindow}
+
+BackingStoreType :: enum NS.UInteger {
+	Retained    = 0,
+	Nonretained = 1,
+	Buffered    = 2,
+}
+
 @(objc_class="NSColor")
 Color :: struct {using _: Object}
 
 @(objc_class="CALayer")
 Layer :: struct { using _: NS.Object }
 
+@(objc_type=Layer, objc_name="contentsScale")
+Layer_contentsScale :: proc(self: ^Layer) -> Float {
+	return msgSend(Float, self, "contentsScale")
+}
+@(objc_type=Layer, objc_name="setContentsScale")
+Layer_setContentsScale :: proc(self: ^Layer, scale: Float) {
+	msgSend(nil, self, "setContentsScale:", scale)
+}
+@(objc_type=Layer, objc_name="frame")
+Layer_frame :: proc(self: ^Layer) -> Rect {
+	return msgSend(Rect, self, "frame")
+}
+@(objc_type=Layer, objc_name="addSublayer")
+Layer_addSublayer :: proc(self: ^Layer, layer: ^Layer) {
+	msgSend(nil, self, "addSublayer:", layer)
+}
+
 @(objc_class="NSResponder")
 Responder :: struct {using _: Object}
 
 @(objc_class="NSView")
 View :: struct {using _: Responder}
 
+
+@(objc_type=View, objc_name="initWithFrame")
+View_initWithFrame :: proc(self: ^View, frame: Rect) -> ^View {
+	return msgSend(^View, self, "initWithFrame:", frame)
+}
 @(objc_type=View, objc_name="layer")
 View_layer :: proc(self: ^View) -> ^Layer {
 	return msgSend(^Layer, self, "layer")
@@ -27,10 +84,6 @@ View_layer :: proc(self: ^View) -> ^Layer {
 View_setLayer :: proc(self: ^View, layer: ^Layer) {
 	msgSend(nil, self, "setLayer:", layer)
 }
-@(objc_type=View, objc_name="setSubLayer")
-View_setSubLayer :: proc(self: ^View, layer: ^Layer) {
-	msgSend(nil, self, "setSubLayer:", layer)
-}
 @(objc_type=View, objc_name="wantsLayer")
 View_wantsLayer :: proc(self: ^View) -> BOOL {
 	return msgSend(BOOL, self, "wantsLayer")
@@ -40,14 +93,26 @@ View_setWantsLayer :: proc(self: ^View, wantsLayer: BOOL) {
 	msgSend(nil, self, "setWantsLayer:", wantsLayer)
 }
 
-
 @(objc_class="NSWindow")
 Window :: struct {using _: Responder}
 
+@(objc_type=Window, objc_name="alloc", objc_is_class_method=true)
+Window_alloc :: proc() -> ^Window {
+	return msgSend(^Window, Window, "alloc")
+}
+
+@(objc_type=Window, objc_name="initWithContentRect")
+Window_initWithContentRect :: proc(self: ^Window, contentRect: Rect, styleMask: WindowStyleMask, backing: BackingStoreType, doDefer: bool) -> ^Window {
+	return msgSend(^Window, self, "initWithContentRect:styleMask:backing:defer:", contentRect, styleMask, backing, doDefer)
+}
 @(objc_type=Window, objc_name="contentView")
 Window_contentView :: proc(self: ^Window) -> ^View {
 	return msgSend(^View, self, "contentView")
 }
+@(objc_type=Window, objc_name="setContentView")
+Window_setContentView :: proc(self: ^Window, content_view: ^View) {
+	msgSend(nil, self, "setContentView:", content_view)
+}
 @(objc_type=Window, objc_name="frame")
 Window_frame :: proc(self: ^Window) -> Rect {
 	return msgSend(Rect, self, "frame")
@@ -72,3 +137,15 @@ Window_backgroundColor :: proc(self: ^Window) -> ^NS.Color {
 Window_setBackgroundColor :: proc(self: ^Window, color: ^NS.Color) {
 	msgSend(nil, self, "setBackgroundColor:", color)
 }
+@(objc_type=Window, objc_name="makeKeyAndOrderFront")
+Window_makeKeyAndOrderFront :: proc(self: ^Window, key: ^NS.Object) {
+	msgSend(nil, self, "makeKeyAndOrderFront:", key)
+}
+@(objc_type=Window, objc_name="setTitle")
+Window_setTitle :: proc(self: ^Window, title: ^NS.String) {
+	msgSend(nil, self, "setTitle:", title)
+}
+@(objc_type=Window, objc_name="close")
+Window_close :: proc(self: ^Window) {
+	msgSend(nil, self, "close")
+}

vendor/darwin/Foundation/objc.odin

@@ -0,0 +1,73 @@
+package objc_Foundation
+
+foreign import "system:Foundation.framework"
+
+import "core:intrinsics"
+import "core:c"
+
+IMP :: proc "c" (object: id, sel: SEL, #c_vararg args: ..any) -> id
+
+foreign Foundation {
+	objc_lookUpClass       :: proc "c" (name: cstring) -> Class ---
+	sel_registerName       :: proc "c" (name: cstring) -> SEL ---
+	objc_allocateClassPair :: proc "c" (superclass: Class, name: cstring, extraBytes: uint) ---
+
+	class_addMethod :: proc "c" (cls: Class, name: SEL, imp: IMP, types: cstring) -> BOOL ---
+}
+
+
+@(objc_class="NSZone")
+Zone :: struct {using _: Object}
+
+@(link_prefix="NS")
+foreign Foundation {
+	AllocateObject   :: proc "c" (aClass: Class, extraBytes: UInteger, zone: ^Zone) -> id ---
+	DeallocateObject :: proc "c" (object: id) ---
+}
+
+Method :: ^objc_method
+objc_method :: struct {
+	method_name:  SEL,
+	method_types: cstring,
+	method_imp:   IMP,
+}
+objc_method_list :: struct {}
+
+objc_ivar :: struct {}
+objc_ivar_list :: struct {}
+
+objc_cache :: struct {
+	mask:     u32,
+	occupied: u32,
+	buckets:  [1]Method,
+}
+
+objc_protocol_list :: struct {
+	next:  ^objc_protocol_list,
+	count: c.int,
+	list:  [1]^Protocol,
+}
+
+@(objc_class="Protocol")
+Protocol :: struct{using _: intrinsics.objc_object}
+
+objc_object_internals :: struct {
+	isa: ^objc_class_internals,
+}
+
+
+objc_class_internals :: struct {
+	isa:           Class,
+	super_class:   Class,
+	name:          cstring,
+	version:       c.long,
+	info:          c.long,
+	instance_size: c.long,
+	ivars:         ^objc_ivar_list,
+	
+	methodLists:   ^^objc_method_list,
+
+	cache:         rawptr,
+	protocols:     rawptr,
+
+}

vendor/darwin/Metal/MetalClasses.odin

@@ -1152,6 +1152,12 @@ CaptureManager_newCaptureScopeWithCommandQueue :: #force_inline proc(self: ^Capt
 CaptureManager_newCaptureScopeWithDevice :: #force_inline proc(self: ^CaptureManager, device: ^Device) -> ^CaptureScope {
 	return msgSend(^CaptureScope, self, "newCaptureScopeWithDevice:", device)
 }
+@(objc_type=CaptureManager, objc_name="newCaptureScope")
+CaptureManager_newCaptureScope :: proc{
+	CaptureManager_newCaptureScopeWithCommandQueue,
+	CaptureManager_newCaptureScopeWithDevice,
+}
+
 @(objc_type=CaptureManager, objc_name="setDefaultCaptureScope")
 CaptureManager_setDefaultCaptureScope :: #force_inline proc(self: ^CaptureManager, defaultCaptureScope: ^CaptureScope) {
 	msgSend(nil, self, "setDefaultCaptureScope:", defaultCaptureScope)
@@ -4474,16 +4480,16 @@ TextureDescriptor_storageMode :: #force_inline proc(self: ^TextureDescriptor) ->
 TextureDescriptor_swizzle :: #force_inline proc(self: ^TextureDescriptor) -> TextureSwizzleChannels {
 	return msgSend(TextureSwizzleChannels, self, "swizzle")
 }
-@(objc_type=TextureDescriptor, objc_name="texture2DDescriptor", objc_is_class_method=true)
-TextureDescriptor_texture2DDescriptor :: #force_inline proc(pixelFormat: PixelFormat, width: NS.UInteger, height: NS.UInteger, mipmapped: BOOL) -> ^TextureDescriptor {
+@(objc_type=TextureDescriptor, objc_name="texture2DDescriptorWithPixelFormat", objc_is_class_method=true)
+TextureDescriptor_texture2DDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, width: NS.UInteger, height: NS.UInteger, mipmapped: BOOL) -> ^TextureDescriptor {
 	return msgSend(^TextureDescriptor, TextureDescriptor, "texture2DDescriptorWithPixelFormat:width:height:mipmapped:", pixelFormat, width, height, mipmapped)
 }
-@(objc_type=TextureDescriptor, objc_name="textureBufferDescriptor", objc_is_class_method=true)
-TextureDescriptor_textureBufferDescriptor :: #force_inline proc(pixelFormat: PixelFormat, width: NS.UInteger, resourceOptions: ResourceOptions, usage: TextureUsage) -> ^TextureDescriptor {
+@(objc_type=TextureDescriptor, objc_name="textureBufferDescriptorWithPixelFormat", objc_is_class_method=true)
+TextureDescriptor_textureBufferDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, width: NS.UInteger, resourceOptions: ResourceOptions, usage: TextureUsage) -> ^TextureDescriptor {
 	return msgSend(^TextureDescriptor, TextureDescriptor, "textureBufferDescriptorWithPixelFormat:width:resourceOptions:usage:", pixelFormat, width, resourceOptions, usage)
 }
-@(objc_type=TextureDescriptor, objc_name="textureCubeDescriptor", objc_is_class_method=true)
-TextureDescriptor_textureCubeDescriptor :: #force_inline proc(pixelFormat: PixelFormat, size: NS.UInteger, mipmapped: BOOL) -> ^TextureDescriptor {
+@(objc_type=TextureDescriptor, objc_name="textureCubeDescriptorWithPixelFormat", objc_is_class_method=true)
+TextureDescriptor_textureCubeDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, size: NS.UInteger, mipmapped: BOOL) -> ^TextureDescriptor {
 	return msgSend(^TextureDescriptor, TextureDescriptor, "textureCubeDescriptorWithPixelFormat:size:mipmapped:", pixelFormat, size, mipmapped)
 }
 @(objc_type=TextureDescriptor, objc_name="textureType")
@@ -5495,6 +5501,17 @@ Buffer_contents :: #force_inline proc(self: ^Buffer) -> []byte {
 Buffer_contentsPointer :: #force_inline proc(self: ^Buffer) -> rawptr {
 	return msgSend(rawptr, self, "contents")
 }
+@(objc_type=Buffer, objc_name="contentsAsSlice")
+Buffer_contentsAsSlice :: #force_inline proc(self: ^Buffer, $T: typeid/[]$E) -> T {
+	contents := msgSend([^]byte, self, "contents")
+	length := Buffer_length(self)
+	return mem.slice_data_cast(T, contents[:length])
+}
+@(objc_type=Buffer, objc_name="contentsAsType")
+Buffer_contentsAsType :: #force_inline proc(self: ^Buffer, $T: typeid, offset: uintptr = 0) -> ^T {
+	ptr := msgSend(rawptr, self, "contents")
+	return (^T)(uintptr(ptr) + offset)
+}
 @(objc_type=Buffer, objc_name="didModifyRange")
 Buffer_didModifyRange :: #force_inline proc(self: ^Buffer, range: NS.Range) {
 	msgSend(nil, self, "didModifyRange:", range)
@@ -6431,12 +6448,12 @@ Device_maxTransferRate :: #force_inline proc(self: ^Device) -> u64 {
 	return msgSend(u64, self, "maxTransferRate")
 }
 @(objc_type=Device, objc_name="minimumLinearTextureAlignmentForPixelFormat")
-Device_minimumLinearTextureAlignmentForPixelFormat :: #force_inline proc(self: ^Device, format: PixelFormat) -> ^Device {
-	return msgSend(^Device, self, "minimumLinearTextureAlignmentForPixelFormat:", format)
+Device_minimumLinearTextureAlignmentForPixelFormat :: #force_inline proc(self: ^Device, format: PixelFormat) -> NS.UInteger {
+	return msgSend(NS.UInteger, self, "minimumLinearTextureAlignmentForPixelFormat:", format)
 }
 @(objc_type=Device, objc_name="minimumTextureBufferAlignmentForPixelFormat")
-Device_minimumTextureBufferAlignmentForPixelFormat :: #force_inline proc(self: ^Device, format: PixelFormat) -> ^Device {
-	return msgSend(^Device, self, "minimumTextureBufferAlignmentForPixelFormat:", format)
+Device_minimumTextureBufferAlignmentForPixelFormat :: #force_inline proc(self: ^Device, format: PixelFormat) -> NS.UInteger {
+	return msgSend(NS.UInteger, self, "minimumTextureBufferAlignmentForPixelFormat:", format)
 }
 @(objc_type=Device, objc_name="name")
 Device_name :: #force_inline proc(self: ^Device) -> ^NS.String {
@@ -6490,35 +6507,46 @@ Device_newCommandQueueWithMaxCommandBufferCount :: #force_inline proc(self: ^Dev
 	return msgSend(^CommandQueue, self, "newCommandQueueWithMaxCommandBufferCount:", maxCommandBufferCount)
 }
 @(objc_type=Device, objc_name="newComputePipelineStateWithDescriptorWithCompletionHandler")
-Device_newComputePipelineStateWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) {
-	msgSend(nil, self, "newComputePipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler)
+Device_newComputePipelineStateWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) -> ^ComputePipelineState {
+	return msgSend(^ComputePipelineState, self, "newComputePipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler)
 }
 @(objc_type=Device, objc_name="newComputePipelineStateWithDescriptorWithReflection")
-Device_newComputePipelineStateWithDescriptorWithReflection :: #force_inline proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection) -> (device: ^Device, error: ^NS.Error) {
-	device = msgSend(^Device, self, "newComputePipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, &error)
+Device_newComputePipelineStateWithDescriptorWithReflection :: #force_inline proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection) -> (res: ^ComputePipelineState, error: ^NS.Error) {
+	res = msgSend(^ComputePipelineState, self, "newComputePipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, &error)
 	return
 }
 @(objc_type=Device, objc_name="newComputePipelineStateWithFunctionWithCompletionHandler")
-Device_newComputePipelineStateWithFunctionWithCompletionHandler :: #force_inline proc(self: ^Device, computeFunction: ^Function, completionHandler: NewComputePipelineStateCompletionHandler) {
-	msgSend(nil, self, "newComputePipelineStateWithFunction:completionHandler:", computeFunction, completionHandler)
+Device_newComputePipelineStateWithFunctionWithCompletionHandler :: #force_inline proc(self: ^Device, computeFunction: ^Function, completionHandler: NewComputePipelineStateCompletionHandler) -> ^ComputePipelineState {
+	return msgSend(^ComputePipelineState, self, "newComputePipelineStateWithFunction:completionHandler:", computeFunction, completionHandler)
 }
 @(objc_type=Device, objc_name="newComputePipelineStateWithFunction")
-Device_newComputePipelineStateWithFunction :: #force_inline proc(self: ^Device, computeFunction: ^Function) -> (res: ^Device, error: ^NS.Error) {
-	res = msgSend(^Device, self, "newComputePipelineStateWithFunction:error:", computeFunction, &error)
+Device_newComputePipelineStateWithFunction :: #force_inline proc(self: ^Device, computeFunction: ^Function) -> (res: ^ComputePipelineState, error: ^NS.Error) {
+	res = msgSend(^ComputePipelineState, self, "newComputePipelineStateWithFunction:error:", computeFunction, &error)
 	return
 }
 @(objc_type=Device, objc_name="newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler")
-Device_newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler :: #force_inline proc(self: ^Device, computeFunction: ^Function, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) {
-	msgSend(nil, self, "newComputePipelineStateWithFunction:options:completionHandler:", computeFunction, options, completionHandler)
+Device_newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler :: #force_inline proc(self: ^Device, computeFunction: ^Function, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) -> (res: ^ComputePipelineState) {
+	return msgSend(^ComputePipelineState, self, "newComputePipelineStateWithFunction:options:completionHandler:", computeFunction, options, completionHandler)
 }
 @(objc_type=Device, objc_name="newComputePipelineStateWithFunctionWithReflection")
-Device_newComputePipelineStateWithFunctionWithReflection :: #force_inline proc(self: ^Device, computeFunction: ^Function, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection) -> (device: ^Device, error: ^NS.Error) {
-	device = msgSend(^Device, self, "newComputePipelineStateWithFunction:options:reflection:error:", computeFunction, options, reflection, &error)
+Device_newComputePipelineStateWithFunctionWithReflection :: #force_inline proc(self: ^Device, computeFunction: ^Function, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection) -> (res: ^ComputePipelineState, error: ^NS.Error) {
+	res = msgSend(^ComputePipelineState, self, "newComputePipelineStateWithFunction:options:reflection:error:", computeFunction, options, reflection, &error)
 	return
 }
+
+@(objc_type=Device, objc_name="newComputePipelineState")
+Device_newComputePipelineState :: proc{
+	Device_newComputePipelineStateWithDescriptorWithCompletionHandler,
+	Device_newComputePipelineStateWithDescriptorWithReflection,
+	Device_newComputePipelineStateWithFunctionWithCompletionHandler,
+	Device_newComputePipelineStateWithFunction,
+	Device_newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler,
+	Device_newComputePipelineStateWithFunctionWithReflection,
+}
+
 @(objc_type=Device, objc_name="newCounterSampleBuffer")
-Device_newCounterSampleBuffer :: #force_inline proc(self: ^Device, descriptor: ^CounterSampleBufferDescriptor) -> (device: ^Device, error: ^NS.Error) {
-	device = msgSend(^Device, self, "newCounterSampleBufferWithDescriptor:error:", descriptor, &error)
+Device_newCounterSampleBuffer :: #force_inline proc(self: ^Device, descriptor: ^CounterSampleBufferDescriptor) -> (counter: ^Counter, error: ^NS.Error) {
+	counter = msgSend(^Counter, self, "newCounterSampleBufferWithDescriptor:error:", descriptor, &error)
 	return
 }
 @(objc_type=Device, objc_name="newDefaultLibrary")
@@ -6560,6 +6588,7 @@ Device_newHeap :: #force_inline proc(self: ^Device, descriptor: ^HeapDescriptor)
 Device_newIndirectCommandBuffer :: #force_inline proc(self: ^Device, descriptor: ^IndirectCommandBufferDescriptor, maxCount: NS.UInteger, options: ResourceOptions) -> ^IndirectCommandBuffer {
 	return msgSend(^IndirectCommandBuffer, self, "newIndirectCommandBufferWithDescriptor:maxCommandCount:options:", descriptor, maxCount, options)
 }
+
 @(objc_type=Device, objc_name="newLibraryWithData")
 Device_newLibraryWithData :: #force_inline proc(self: ^Device, data: dispatch_data_t) -> (library: ^Library, error: ^NS.Error) {
 	library = msgSend(^Library, self, "newLibraryWithData:error:", data, &error)
@@ -6584,16 +6613,27 @@ Device_newLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL) -> (
 	library = msgSend(^Library, self, "newLibraryWithURL:error:", url, &error)
 	return
 }
+@(objc_type=Device, objc_name="newLibrary")
+Device_newLibrary :: proc{
+	Device_newLibraryWithData,
+	Device_newLibraryWithFile,
+	Device_newLibraryWithSourceWithCompletionHandler,
+	Device_newLibraryWithSource,
+	Device_newLibraryWithURL,
+}
+
+
 @(objc_type=Device, objc_name="newRasterizationRateMap")
 Device_newRasterizationRateMap :: #force_inline proc(self: ^Device, descriptor: ^RasterizationRateMapDescriptor) -> ^RasterizationRateMap {
 	return msgSend(^RasterizationRateMap, self, "newRasterizationRateMapWithDescriptor:", descriptor)
 }
+
 @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptorWithCompletionHandler")
 Device_newRenderPipelineStateWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, completionHandler: NewRenderPipelineStateCompletionHandler) -> ^RenderPipelineState {
 	return msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithDescriptor:completionHandler:", descriptor, completionHandler)
 }
-@(objc_type=Device, objc_name="newRenderPipelineState")
-Device_newRenderPipelineState :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) {
+@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor")
+Device_newRenderPipelineStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) {
 	pipeline = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithDescriptor:error:", descriptor, &error)
 	return
 }
@@ -6615,6 +6655,17 @@ Device_newRenderPipelineStateWithTileDescriptorWithReflection :: #force_inline p
 	pipeline = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, &error)
 	return
 }
+@(objc_type=Device, objc_name="newRenderPipelineState")
+Device_newRenderPipelineState :: proc{
+	Device_newRenderPipelineStateWithDescriptorWithCompletionHandler,
+	Device_newRenderPipelineStateWithDescriptor,
+	Device_newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler,
+	Device_newRenderPipelineStateWithDescriptorWithReflection,
+	Device_newRenderPipelineStateWithTileDescriptorWithCompletionHandler,
+	Device_newRenderPipelineStateWithTileDescriptorWithReflection,
+}
+
+
 @(objc_type=Device, objc_name="newSamplerState")
 Device_newSamplerState :: #force_inline proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^SamplerState {
 	return msgSend(^SamplerState, self, "newSamplerStateWithDescriptor:", descriptor)
@@ -6627,22 +6678,34 @@ Device_newSharedEvent :: #force_inline proc(self: ^Device) -> ^SharedEvent {
 Device_newSharedEventWithHandle :: #force_inline proc(self: ^Device, sharedEventHandle: ^SharedEventHandle) -> ^SharedEvent {
 	return msgSend(^SharedEvent, self, "newSharedEventWithHandle:", sharedEventHandle)
 }
-@(objc_type=Device, objc_name="newSharedTexture")
-Device_newSharedTexture :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor) -> ^SharedEvent {
+@(objc_type=Device, objc_name="newSharedTextureWithDescriptor")
+Device_newSharedTextureWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor) -> ^SharedEvent {
 	return msgSend(^SharedEvent, self, "newSharedTextureWithDescriptor:", descriptor)
 }
 @(objc_type=Device, objc_name="newSharedTextureWithHandle")
 Device_newSharedTextureWithHandle :: #force_inline proc(self: ^Device, sharedHandle: ^SharedTextureHandle) -> ^SharedEvent {
 	return msgSend(^SharedEvent, self, "newSharedTextureWithHandle:", sharedHandle)
 }
-@(objc_type=Device, objc_name="newTexture")
-Device_newTexture :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> ^Texture {
+@(objc_type=Device, objc_name="newSharedTexture")
+Device_newSharedTexture :: proc{
+	Device_newSharedTextureWithDescriptor,
+	Device_newSharedTextureWithHandle,
+}
+
+@(objc_type=Device, objc_name="newTextureWithDescriptor")
+Device_newTextureWithDescriptor :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> ^Texture {
 	return msgSend(^Texture, self, "newTextureWithDescriptor:", desc)
 }
 @(objc_type=Device, objc_name="newTextureWithIOSurface")
 Device_newTextureWithIOSurface :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: NS.UInteger) -> ^Texture {
 	return msgSend(^Texture, self, "newTextureWithDescriptor:iosurface:plane:", descriptor, iosurface, plane)
 }
+@(objc_type=Device, objc_name="newTexture")
+Device_newTexture :: proc{
+	Device_newTextureWithDescriptor,
+	Device_newTextureWithIOSurface,
+}
+
 @(objc_type=Device, objc_name="peerCount")
 Device_peerCount :: #force_inline proc(self: ^Device) -> u32 {
 	return msgSend(u32, self, "peerCount")
@@ -7104,22 +7167,34 @@ Heap_label :: #force_inline proc(self: ^Heap) -> ^NS.String {
 Heap_maxAvailableSizeWithAlignment :: #force_inline proc(self: ^Heap, alignment: NS.UInteger) -> NS.UInteger {
 	return msgSend(NS.UInteger, self, "maxAvailableSizeWithAlignment:", alignment)
 }
-@(objc_type=Heap, objc_name="newBuffer")
-Heap_newBuffer :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions) -> ^Buffer {
+@(objc_type=Heap, objc_name="newBufferWithLength")
+Heap_newBufferWithLength :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions) -> ^Buffer {
 	return msgSend(^Buffer, self, "newBufferWithLength:options:", length, options)
 }
 @(objc_type=Heap, objc_name="newBufferWithOptions")
 Heap_newBufferWithOptions :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions, offset: NS.UInteger) -> ^Buffer {
 	return msgSend(^Buffer, self, "newBufferWithLength:options:offset:", length, options, offset)
 }
-@(objc_type=Heap, objc_name="newTexture")
-Heap_newTexture :: #force_inline proc(self: ^Heap, desc: ^TextureDescriptor) -> ^Texture {
+@(objc_type=Heap, objc_name="newBuffer")
+Heap_newBuffer :: proc{
+	Heap_newBufferWithLength,
+	Heap_newBufferWithOptions,
+}
+
+@(objc_type=Heap, objc_name="newTextureWithDescriptor")
+Heap_newTextureWithDescriptor :: #force_inline proc(self: ^Heap, desc: ^TextureDescriptor) -> ^Texture {
 	return msgSend(^Texture, self, "newTextureWithDescriptor:", desc)
 }
-@(objc_type=Heap, objc_name="newTextureWithOffset")
-Heap_newTextureWithOffset :: #force_inline proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: NS.UInteger) -> ^Texture {
+@(objc_type=Heap, objc_name="newTextureWithDescriptorAndOffset")
+Heap_newTextureWithDescriptorAndOffset :: #force_inline proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: NS.UInteger) -> ^Texture {
 	return msgSend(^Texture, self, "newTextureWithDescriptor:offset:", descriptor, offset)
 }
+@(objc_type=Heap, objc_name="newTexture")
+Heap_newTexture :: proc{
+	Heap_newTextureWithDescriptor,
+	Heap_newTextureWithDescriptorAndOffset,
+}
+
 @(objc_type=Heap, objc_name="resourceOptions")
 Heap_resourceOptions :: #force_inline proc(self: ^Heap) -> ResourceOptions {
 	return msgSend(ResourceOptions, self, "resourceOptions")
@@ -7388,7 +7463,7 @@ Library_label :: #force_inline proc(self: ^Library) -> ^NS.String {
 	return msgSend(^NS.String, self, "label")
 }
 @(objc_type=Library, objc_name="newFunctionWithCompletionHandler")
-Library_newFunctionWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: rawptr) -> ^Function {
+Library_newFunctionWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: ^NS.Block) -> ^Function {
 	return msgSend(^Function, self, "newFunctionWithDescriptor:completionHandler:", descriptor, completionHandler)
 }
 @(objc_type=Library, objc_name="newFunctionWithDescriptor")
@@ -7401,7 +7476,7 @@ Library_newFunctionWithName :: #force_inline proc(self: ^Library, functionName:
 	return msgSend(^Function, self, "newFunctionWithName:", functionName)
 }
 @(objc_type=Library, objc_name="newFunctionWithConstantValuesAndCompletionHandler")
-Library_newFunctionWithConstantValuesAndCompletionHandler :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: rawptr) -> ^Function {
+Library_newFunctionWithConstantValuesAndCompletionHandler :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: ^NS.Block) -> ^Function {
 	return msgSend(^Function, self, "newFunctionWithName:constantValues:completionHandler:", name, constantValues, completionHandler)
 }
 @(objc_type=Library, objc_name="newFunctionWithConstantValues")
@@ -7409,8 +7484,17 @@ Library_newFunctionWithConstantValues :: #force_inline proc(self: ^Library, name
 	function = msgSend(^Function, self, "newFunctionWithName:constantValues:error:", name, constantValues, &error)
 	return
 }
+@(objc_type=Library, objc_name="newFunction")
+Library_newFunction :: proc{
+	Library_newFunctionWithCompletionHandler,
+	Library_newFunctionWithDescriptor,
+	Library_newFunctionWithName,
+	Library_newFunctionWithConstantValuesAndCompletionHandler,
+	Library_newFunctionWithConstantValues,
+}
+
 @(objc_type=Library, objc_name="newIntersectionFunctionWithCompletionHandler")
-Library_newIntersectionFunctionWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) -> ^Function {
+Library_newIntersectionFunctionWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: ^NS.Block) -> ^Function {
 	return msgSend(^Function, self, "newIntersectionFunctionWithDescriptor:completionHandler:", descriptor, completionHandler)
 }
 @(objc_type=Library, objc_name="newIntersectionFunction")
@@ -7683,7 +7767,7 @@ RenderCommandEncoder_drawPrimitivesWithInstanceCount :: #force_inline proc(self:
 	msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:", primitiveType, vertexStart, vertexCount, instanceCount)
 }
 @(objc_type=RenderCommandEncoder, objc_name="drawPrimitivesWithInstances")
-RenderCommandEncoder_drawPrimitivesWithInstance :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) {
+RenderCommandEncoder_drawPrimitivesWithInstances :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) {
 	msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance)
 }
 @(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBuffer")

vendor/darwin/Metal/MetalProcedures.odin

@@ -11,4 +11,9 @@ foreign Metal {
 	CopyAllDevicesWithObserver :: proc(observer: ^id, handler: DeviceNotificationHandler) -> ^NS.Array ---
 	CreateSystemDefaultDevice  :: proc() -> ^Device ---
 	RemoveDeviceObserver       :: proc(observer: id) ---
+}
+
+
+new :: proc($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, NS.Object) {
+	return T.alloc()->init()
 }

vendor/darwin/Metal/MetalTypes.odin

@@ -184,16 +184,16 @@ Viewport :: struct {
 
 Timestamp :: distinct u64
 
-DeviceNotificationHandler                              :: distinct rawptr
+DeviceNotificationHandler                              :: ^NS.Block
 AutoreleasedComputePipelineReflection                  :: ^ComputePipelineReflection
 AutoreleasedRenderPipelineReflection                   :: ^RenderPipelineReflection
-NewLibraryCompletionHandler                            :: distinct rawptr
-NewRenderPipelineStateCompletionHandler                :: distinct rawptr
-NewRenderPipelineStateWithReflectionCompletionHandler  :: distinct rawptr
-NewComputePipelineStateCompletionHandler               :: distinct rawptr
-NewComputePipelineStateWithReflectionCompletionHandler :: distinct rawptr
-SharedEventNotificationBlock :: distinct rawptr
+NewLibraryCompletionHandler                            :: ^NS.Block
+NewRenderPipelineStateCompletionHandler                :: ^NS.Block
+NewRenderPipelineStateWithReflectionCompletionHandler  :: ^NS.Block
+NewComputePipelineStateCompletionHandler               :: ^NS.Block
+NewComputePipelineStateWithReflectionCompletionHandler :: ^NS.Block
+SharedEventNotificationBlock :: ^NS.Block
 
-DrawablePresentedHandler :: distinct rawptr
+DrawablePresentedHandler :: ^NS.Block
 
 AutoreleasedArgument :: ^Argument

vendor/darwin/MetalKit/MetalKit.odin

@@ -0,0 +1,259 @@
+package objc_MetalKit
+
+import NS "vendor:darwin/Foundation"
+import MTL "vendor:darwin/Metal"
+import CA "vendor:darwin/QuartzCore"
+import "core:intrinsics"
+
+@(require)
+foreign import "system:MetalKit.framework"
+
+@(private)
+msgSend :: intrinsics.objc_send
+
+ColorSpaceRef :: struct {}
+
+ViewDelegate :: struct {
+	drawInMTKView:          proc "c" (self: ^ViewDelegate, view: ^View),
+	drawableSizeWillChange: proc "c" (self: ^ViewDelegate, view: ^View, size: NS.Size),
+
+	user_data: rawptr,
+}
+
+@(objc_class="MTKView")
+View :: struct {using _: NS.View}
+
+@(objc_type=View, objc_name="alloc", objc_is_class_method=true)
+View_alloc :: proc() -> ^View {
+	return msgSend(^View, View, "alloc")
+}
+@(objc_type=View, objc_name="initWithFrame")
+View_initWithFrame :: proc(self: ^View, frame: NS.Rect, device: ^MTL.Device) -> ^View {
+	return msgSend(^View, self, "initWithFrame:device:", frame, device)
+}
+@(objc_type=View, objc_name="initWithCoder")
+View_initWithCoder :: proc(self: ^View, coder: ^NS.Coder) -> ^View {
+	return msgSend(^View, self, "initWithCoder:", coder)
+}
+
+@(objc_type=View, objc_name="setDevice")
+View_setDevice :: proc(self: ^View, device: ^MTL.Device) {
+	msgSend(nil, self, "setDevice:", device)
+}
+@(objc_type=View, objc_name="device")
+View_device :: proc(self: ^View) -> ^MTL.Device {
+	return msgSend(^MTL.Device, self, "device")
+}
+
+@(objc_type=View, objc_name="draw")
+View_draw :: proc(self: ^View) {
+	msgSend(nil, self, "draw")
+}
+
+@(objc_type=View, objc_name="setDelegate")
+View_setDelegate :: proc(self: ^View, delegate: ^ViewDelegate) {
+	drawDispatch :: proc "c" (self: ^NS.Value, cmd: NS.SEL, view: ^View) {
+		del := (^ViewDelegate)(self->pointerValue())
+		del->drawInMTKView(view)
+	}
+	drawableSizeWillChange :: proc "c" (self: ^NS.Value, cmd: NS.SEL, view: ^View, size: NS.Size) {
+		del := (^ViewDelegate)(self->pointerValue())
+		del->drawableSizeWillChange(view, size)
+	}
+
+	wrapper := NS.Value.valueWithPointer(delegate)
+
+	NS.class_addMethod(intrinsics.objc_find_class("NSValue"), intrinsics.objc_find_selector("drawInMTKView:"), auto_cast drawDispatch, "v@:@")
+
+	cbparams :: "v@:@{CGSize=ff}" when size_of(NS.Float) == size_of(f32) else "v@:@{CGSize=dd}"
+	NS.class_addMethod(intrinsics.objc_find_class("NSValue"), intrinsics.objc_find_selector("mtkView:drawableSizeWillChange:"), auto_cast drawableSizeWillChange, cbparams)
+
+	msgSend(nil, self, "setDelegate:", wrapper)
+}
+
+@(objc_type=View, objc_name="delegate")
+View_delegate :: proc(self: ^View) -> ^ViewDelegate {
+	wrapper := msgSend(^NS.Value, self, "delegate")
+	if wrapper != nil {
+		return (^ViewDelegate)(wrapper->pointerValue())
+	}
+	return nil
+}
+
+@(objc_type=View, objc_name="currentDrawable")
+View_currentDrawable :: proc(self: ^View) -> ^CA.MetalDrawable {
+	return msgSend(^CA.MetalDrawable, self, "currentDrawable")
+}
+
+@(objc_type=View, objc_name="setFramebufferOnly")
+View_setFramebufferOnly :: proc(self: ^View, framebufferOnly: bool) {
+	msgSend(nil, self, "setFramebufferOnly:", framebufferOnly)
+}
+@(objc_type=View, objc_name="framebufferOnly")
+View_framebufferOnly :: proc(self: ^View) -> bool {
+	return msgSend(bool, self, "framebufferOnly")
+}
+
+@(objc_type=View, objc_name="setDepthStencilAttachmentTextureUsage")
+View_setDepthStencilAttachmentTextureUsage :: proc(self: ^View, textureUsage: MTL.TextureUsage) {
+	msgSend(nil, self, "setDepthStencilAttachmentTextureUsage:", textureUsage)
+}
+@(objc_type=View, objc_name="depthStencilAttachmentTextureUsage")
+View_depthStencilAttachmentTextureUsage :: proc(self: ^View) -> MTL.TextureUsage {
+	return msgSend(MTL.TextureUsage, self, "depthStencilAttachmentTextureUsage")
+}
+
+@(objc_type=View, objc_name="setMultisampleColorAttachmentTextureUsage")
+View_setMultisampleColorAttachmentTextureUsage :: proc(self: ^View, textureUsage: MTL.TextureUsage) {
+	msgSend(nil, self, "setMultisampleColorAttachmentTextureUsage:", textureUsage)
+}
+@(objc_type=View, objc_name="multisampleColorAttachmentTextureUsage")
+View_multisampleColorAttachmentTextureUsage :: proc(self: ^View) -> MTL.TextureUsage {
+	return msgSend(MTL.TextureUsage, self, "multisampleColorAttachmentTextureUsage")
+}
+
+@(objc_type=View, objc_name="setPresentsWithTransaction")
+View_setPresentsWithTransaction :: proc(self: ^View, presentsWithTransaction: bool) {
+	msgSend(nil, self, "setPresentsWithTransaction:", presentsWithTransaction)
+}
+@(objc_type=View, objc_name="presentsWithTransaction")
+View_presentsWithTransaction :: proc(self: ^View) -> bool {
+	return msgSend(bool, self, "presentsWithTransaction")
+}
+
+@(objc_type=View, objc_name="setColorPixelFormat")
+View_setColorPixelFormat :: proc(self: ^View, colorPixelFormat: MTL.PixelFormat) {
+	msgSend(nil, self, "setColorPixelFormat:", colorPixelFormat)
+}
+@(objc_type=View, objc_name="colorPixelFormat")
+View_colorPixelFormat :: proc(self: ^View) -> MTL.PixelFormat {
+	return msgSend(MTL.PixelFormat, self, "colorPixelFormat")
+}
+
+@(objc_type=View, objc_name="setDepthStencilPixelFormat")
+View_setDepthStencilPixelFormat :: proc(self: ^View, colorPixelFormat: MTL.PixelFormat) {
+	msgSend(nil, self, "setDepthStencilPixelFormat:", colorPixelFormat)
+}
+@(objc_type=View, objc_name="depthStencilPixelFormat")
+View_depthStencilPixelFormat :: proc(self: ^View) -> MTL.PixelFormat {
+	return msgSend(MTL.PixelFormat, self, "depthStencilPixelFormat")
+}
+
+@(objc_type=View, objc_name="setSampleCount")
+View_setSampleCount :: proc(self: ^View, sampleCount: NS.UInteger) {
+	msgSend(nil, self, "setSampleCount:", sampleCount)
+}
+@(objc_type=View, objc_name="sampleCount")
+View_sampleCount :: proc(self: ^View) -> NS.UInteger {
+	return msgSend(NS.UInteger, self, "sampleCount")
+}
+
+@(objc_type=View, objc_name="setClearColor")
+View_setClearColor :: proc(self: ^View, clearColor: MTL.ClearColor) {
+	msgSend(nil, self, "setClearColor:", clearColor)
+}
+@(objc_type=View, objc_name="clearColor")
+View_clearColor :: proc(self: ^View) -> MTL.ClearColor {
+	return msgSend(MTL.ClearColor, self, "clearColor")
+}
+
+@(objc_type=View, objc_name="setClearDepth")
+View_setClearDepth :: proc(self: ^View, clearDepth: f64) {
+	msgSend(nil, self, "setClearDepth:", clearDepth)
+}
+@(objc_type=View, objc_name="clearDepth")
+View_clearDepth :: proc(self: ^View) -> f64 {
+	return msgSend(f64, self, "clearDepth")
+}
+
+@(objc_type=View, objc_name="setClearStencil")
+View_setClearStencil :: proc(self: ^View, clearStencil: u32) {
+	msgSend(nil, self, "setClearStencil:", clearStencil)
+}
+@(objc_type=View, objc_name="clearStencil")
+View_clearStencil :: proc(self: ^View) -> u32 {
+	return msgSend(u32, self, "clearStencil")
+}
+
+@(objc_type=View, objc_name="depthStencilTexture")
+View_depthStencilTexture :: proc(self: ^View) -> ^MTL.Texture {
+	return msgSend(^MTL.Texture, self, "depthStencilTexture")
+}
+@(objc_type=View, objc_name="multisampleColorTexture")
+View_multisampleColorTexture :: proc(self: ^View) -> ^MTL.Texture {
+	return msgSend(^MTL.Texture, self, "multisampleColorTexture")
+}
+
+@(objc_type=View, objc_name="releaseDrawables")
+View_releaseDrawables :: proc(self: ^View) {
+	msgSend(nil, self, "releaseDrawables")
+}
+
+@(objc_type=View, objc_name="currentRenderPassDescriptor")
+View_currentRenderPassDescriptor :: proc(self: ^View) -> ^MTL.RenderPassDescriptor {
+	return msgSend(^MTL.RenderPassDescriptor, self, "currentRenderPassDescriptor")
+}
+
+@(objc_type=View, objc_name="setPreferredFramesPerSecond")
+View_setPreferredFramesPerSecond :: proc(self: ^View, preferredFramesPerSecond: NS.Integer) {
+	msgSend(nil, self, "setPreferredFramesPerSecond:", preferredFramesPerSecond)
+}
+@(objc_type=View, objc_name="preferredFramesPerSecond")
+View_preferredFramesPerSecond :: proc(self: ^View) -> NS.Integer {
+	return msgSend(NS.Integer, self, "preferredFramesPerSecond")
+}
+
+@(objc_type=View, objc_name="setEnableSetNeedsDisplay")
+View_setEnableSetNeedsDisplay :: proc(self: ^View, enableSetNeedsDisplay: bool) {
+	msgSend(nil, self, "setEnableSetNeedsDisplay:", enableSetNeedsDisplay)
+}
+@(objc_type=View, objc_name="enableSetNeedsDisplay")
+View_enableSetNeedsDisplay :: proc(self: ^View) -> bool {
+	return msgSend(bool, self, "enableSetNeedsDisplay")
+}
+
+@(objc_type=View, objc_name="setAutoresizeDrawable")
+View_setAutoresizeDrawable :: proc(self: ^View, autoresizeDrawable: bool) {
+	msgSend(nil, self, "setAutoresizeDrawable:", autoresizeDrawable)
+}
+@(objc_type=View, objc_name="autoresizeDrawable")
+View_autoresizeDrawable :: proc(self: ^View) -> bool {
+	return msgSend(bool, self, "autoresizeDrawable")
+}
+
+@(objc_type=View, objc_name="setDrawableSize")
+View_setDrawableSize :: proc(self: ^View, drawableSize: NS.Size) {
+	msgSend(nil, self, "setDrawableSize:", drawableSize)
+}
+@(objc_type=View, objc_name="drawableSize")
+View_drawableSize :: proc(self: ^View) -> NS.Size {
+	return msgSend(NS.Size, self, "drawableSize")
+}
+
+@(objc_type=View, objc_name="preferredDrawableSize")
+View_preferredDrawableSize :: proc(self: ^View) -> NS.Size {
+	return msgSend(NS.Size, self, "preferredDrawableSize")
+}
+
+@(objc_type=View, objc_name="preferredDevice")
+View_preferredDevice :: proc(self: ^View) -> ^MTL.Device {
+	return msgSend(^MTL.Device, self, "preferredDevice")
+}
+
+@(objc_type=View, objc_name="setPaused")
+View_setPaused :: proc(self: ^View, isPaused: bool) {
+	msgSend(nil, self, "setPaused:", isPaused)
+}
+@(objc_type=View, objc_name="isPaused")
+View_isPaused :: proc(self: ^View) -> bool {
+	return msgSend(bool, self, "isPaused")
+}
+
+@(objc_type=View, objc_name="setColorSpace")
+View_setColorSpace :: proc(self: ^View, colorSpace: ColorSpaceRef) {
+	msgSend(nil, self, "setColorSpace:", colorSpace)
+}
+@(objc_type=View, objc_name="colorSpace")
+View_colorSpace :: proc(self: ^View) -> ColorSpaceRef {
+	return msgSend(ColorSpaceRef, self, "colorSpace")
+}

vendor/vulkan/_gen/create_vulkan_odin_wrapper.py

@@ -7,14 +7,14 @@ import os.path
 import math
 
 file_and_urls = [
-    ("vk_platform.h",  'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vk_platform.h',  True),
-    ("vulkan_core.h",  'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h',  False),
-    ("vk_layer.h",     'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vk_layer.h',     True),
-    ("vk_icd.h",       'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vk_icd.h',       True),
-    ("vulkan_win32.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_win32.h', False),
-    ("vulkan_metal.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_metal.h', False),
-    ("vulkan_macos.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_macos.h', False),
-    ("vulkan_ios.h",   'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_ios.h',   False),
+    ("vk_platform.h",  'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vulkan/vk_platform.h',  True),
+    ("vulkan_core.h",  'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vulkan/vulkan_core.h',  False),
+    ("vk_layer.h",     'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vulkan/vk_layer.h',     True),
+    ("vk_icd.h",       'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vulkan/vk_icd.h',       True),
+    ("vulkan_win32.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vulkan/vulkan_win32.h', False),
+    ("vulkan_metal.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vulkan/vulkan_metal.h', False),
+    ("vulkan_macos.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vulkan/vulkan_macos.h', False),
+    ("vulkan_ios.h",   'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vulkan/vulkan_ios.h',   False),
 ]
 
 for file, url, _ in file_and_urls:
@@ -125,7 +125,7 @@ def to_snake_case(name):
     s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
     return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
 
-ext_suffixes = ["KHR", "EXT", "AMD", "NV", "NVX", "GOOGLE"]
+ext_suffixes = ["KHR", "EXT", "AMD", "NV", "NVX", "GOOGLE", "KHX"]
 ext_suffixes_title = [ext.title() for ext in ext_suffixes]
 
 
@@ -254,9 +254,19 @@ def parse_constants(f):
         f.write("{}{} :: {}\n".format(name, "".rjust(max_len-len(name)), value))
 
     f.write("\n// Vendor Constants\n")
-    data = re.findall(r"#define VK_((?:"+'|'.join(ext_suffixes)+r")\w+)\s*(.*?)\n", src, re.S)
+    fixes = '|'.join(ext_suffixes)
+    inner = r"((?:(?:" + fixes + r")\w+)|(?:\w+" + fixes + r"))"
+    pattern = r"#define\s+VK_" + inner + r"\s*(.*?)\n"
+    data = re.findall(pattern, src, re.S)
+
+    number_suffix_re = re.compile(r"(\d+)[UuLlFf]")
+
     max_len = max(len(name) for name, value in data)
     for name, value in data:
+        value = remove_prefix(value, 'VK_')
+        v = number_suffix_re.findall(value)
+        if v:
+            value = v[0]
         f.write("{}{} :: {}\n".format(name, "".rjust(max_len-len(name)), value))
     f.write("\n")
 
@@ -652,15 +662,12 @@ MAX_MEMORY_TYPES              :: 32
 MAX_MEMORY_HEAPS              :: 16
 MAX_EXTENSION_NAME_SIZE       :: 256
 MAX_DESCRIPTION_SIZE          :: 256
-MAX_DEVICE_GROUP_SIZE_KHX     :: 32
 MAX_DEVICE_GROUP_SIZE         :: 32
 LUID_SIZE_KHX                 :: 8
-LUID_SIZE_KHR                 :: 8
 LUID_SIZE                     :: 8
-MAX_DRIVER_NAME_SIZE_KHR      :: 256
-MAX_DRIVER_INFO_SIZE_KHR      :: 256
-MAX_QUEUE_FAMILY_EXTERNAL     :: ~u32(0)-1
+MAX_QUEUE_FAMILY_EXTERNAL     :: ~u32(1)
 MAX_GLOBAL_PRIORITY_SIZE_EXT  :: 16
+QUEUE_FAMILY_EXTERNAL         :: MAX_QUEUE_FAMILY_EXTERNAL
 
 """[1::])
     parse_constants(f)

vendor/vulkan/_gen/vk_icd.h

@@ -33,7 +33,7 @@
 //   Version 2 - Add Loader/ICD Interface version negotiation
 //               via vk_icdNegotiateLoaderICDInterfaceVersion.
 //   Version 3 - Add ICD creation/destruction of KHR_surface objects.
-//   Version 4 - Add unknown physical device extension qyering via
+//   Version 4 - Add unknown physical device extension querying via
 //               vk_icdGetPhysicalDeviceProcAddr.
 //   Version 5 - Tells ICDs that the loader is now paying attention to the
 //               application version of Vulkan passed into the ApplicationInfo

vendor/vulkan/_gen/vk_platform.h

@@ -2,7 +2,7 @@
 // File: vk_platform.h
 //
 /*
-** Copyright 2014-2021 The Khronos Group Inc.
+** Copyright 2014-2022 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -42,7 +42,7 @@ extern "C"
     #define VKAPI_CALL __stdcall
     #define VKAPI_PTR  VKAPI_CALL
 #elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
-    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
+    #error "Vulkan is not supported for the 'armeabi' NDK ABI"
 #elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
     // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
     // calling convention, i.e. float parameters are passed in registers. This

vendor/vulkan/_gen/vulkan_ios.h

@@ -2,7 +2,7 @@
 #define VULKAN_IOS_H_ 1
 
 /*
-** Copyright 2015-2021 The Khronos Group Inc.
+** Copyright 2015-2022 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_macos.h

@@ -2,7 +2,7 @@
 #define VULKAN_MACOS_H_ 1
 
 /*
-** Copyright 2015-2021 The Khronos Group Inc.
+** Copyright 2015-2022 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_metal.h

@@ -2,7 +2,7 @@
 #define VULKAN_METAL_H_ 1
 
 /*
-** Copyright 2015-2021 The Khronos Group Inc.
+** Copyright 2015-2022 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/_gen/vulkan_win32.h

@@ -2,7 +2,7 @@
 #define VULKAN_WIN32_H_ 1
 
 /*
-** Copyright 2015-2021 The Khronos Group Inc.
+** Copyright 2015-2022 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

vendor/vulkan/core.odin

@@ -39,18 +39,15 @@ MAX_MEMORY_TYPES              :: 32
 MAX_MEMORY_HEAPS              :: 16
 MAX_EXTENSION_NAME_SIZE       :: 256
 MAX_DESCRIPTION_SIZE          :: 256
-MAX_DEVICE_GROUP_SIZE_KHX     :: 32
 MAX_DEVICE_GROUP_SIZE         :: 32
 LUID_SIZE_KHX                 :: 8
-LUID_SIZE_KHR                 :: 8
 LUID_SIZE                     :: 8
-MAX_DRIVER_NAME_SIZE_KHR      :: 256
-MAX_DRIVER_INFO_SIZE_KHR      :: 256
-MAX_QUEUE_FAMILY_EXTERNAL     :: ~u32(0)-1
+MAX_QUEUE_FAMILY_EXTERNAL     :: ~u32(1)
 MAX_GLOBAL_PRIORITY_SIZE_EXT  :: 16
+QUEUE_FAMILY_EXTERNAL         :: MAX_QUEUE_FAMILY_EXTERNAL
 
 // General Constants
-HEADER_VERSION       :: 191
+HEADER_VERSION       :: 211
 MAX_DRIVER_NAME_SIZE :: 256
 MAX_DRIVER_INFO_SIZE :: 256
 
@@ -70,6 +67,9 @@ KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME                    :: "VK_KHR_display_swapc
 KHR_sampler_mirror_clamp_to_edge                        :: 1
 KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION           :: 3
 KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME         :: "VK_KHR_sampler_mirror_clamp_to_edge"
+KHR_dynamic_rendering                                   :: 1
+KHR_DYNAMIC_RENDERING_SPEC_VERSION                      :: 1
+KHR_DYNAMIC_RENDERING_EXTENSION_NAME                    :: "VK_KHR_dynamic_rendering"
 KHR_multiview                                           :: 1
 KHR_MULTIVIEW_SPEC_VERSION                              :: 1
 KHR_MULTIVIEW_EXTENSION_NAME                            :: "VK_KHR_multiview"
@@ -83,17 +83,22 @@ KHR_shader_draw_parameters                              :: 1
 KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION                 :: 1
 KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME               :: "VK_KHR_shader_draw_parameters"
 KHR_maintenance1                                        :: 1
-KHR_MAINTENANCE1_SPEC_VERSION                           :: 2
-KHR_MAINTENANCE1_EXTENSION_NAME                         :: "VK_KHR_maintenance1"
+KHR_MAINTENANCE_1_SPEC_VERSION                          :: 2
+KHR_MAINTENANCE_1_EXTENSION_NAME                        :: "VK_KHR_maintenance1"
+KHR_MAINTENANCE1_SPEC_VERSION                           :: KHR_MAINTENANCE_1_SPEC_VERSION
+KHR_MAINTENANCE1_EXTENSION_NAME                         :: KHR_MAINTENANCE_1_EXTENSION_NAME
 KHR_device_group_creation                               :: 1
 KHR_DEVICE_GROUP_CREATION_SPEC_VERSION                  :: 1
 KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME                :: "VK_KHR_device_group_creation"
+MAX_DEVICE_GROUP_SIZE_KHR                               :: MAX_DEVICE_GROUP_SIZE
 KHR_external_memory_capabilities                        :: 1
 KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION           :: 1
 KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME         :: "VK_KHR_external_memory_capabilities"
+LUID_SIZE_KHR                                           :: LUID_SIZE
 KHR_external_memory                                     :: 1
 KHR_EXTERNAL_MEMORY_SPEC_VERSION                        :: 1
 KHR_EXTERNAL_MEMORY_EXTENSION_NAME                      :: "VK_KHR_external_memory"
+QUEUE_FAMILY_EXTERNAL_KHR                               :: QUEUE_FAMILY_EXTERNAL
 KHR_external_memory_fd                                  :: 1
 KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION                     :: 1
 KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME                   :: "VK_KHR_external_memory_fd"
@@ -143,8 +148,10 @@ KHR_performance_query                                   :: 1
 KHR_PERFORMANCE_QUERY_SPEC_VERSION                      :: 1
 KHR_PERFORMANCE_QUERY_EXTENSION_NAME                    :: "VK_KHR_performance_query"
 KHR_maintenance2                                        :: 1
-KHR_MAINTENANCE2_SPEC_VERSION                           :: 1
-KHR_MAINTENANCE2_EXTENSION_NAME                         :: "VK_KHR_maintenance2"
+KHR_MAINTENANCE_2_SPEC_VERSION                          :: 1
+KHR_MAINTENANCE_2_EXTENSION_NAME                        :: "VK_KHR_maintenance2"
+KHR_MAINTENANCE2_SPEC_VERSION                           :: KHR_MAINTENANCE_2_SPEC_VERSION
+KHR_MAINTENANCE2_EXTENSION_NAME                         :: KHR_MAINTENANCE_2_EXTENSION_NAME
 KHR_get_surface_capabilities2                           :: 1
 KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION             :: 1
 KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME           :: "VK_KHR_get_surface_capabilities2"
@@ -176,8 +183,10 @@ KHR_bind_memory2                                        :: 1
 KHR_BIND_MEMORY_2_SPEC_VERSION                          :: 1
 KHR_BIND_MEMORY_2_EXTENSION_NAME                        :: "VK_KHR_bind_memory2"
 KHR_maintenance3                                        :: 1
-KHR_MAINTENANCE3_SPEC_VERSION                           :: 1
-KHR_MAINTENANCE3_EXTENSION_NAME                         :: "VK_KHR_maintenance3"
+KHR_MAINTENANCE_3_SPEC_VERSION                          :: 1
+KHR_MAINTENANCE_3_EXTENSION_NAME                        :: "VK_KHR_maintenance3"
+KHR_MAINTENANCE3_SPEC_VERSION                           :: KHR_MAINTENANCE_3_SPEC_VERSION
+KHR_MAINTENANCE3_EXTENSION_NAME                         :: KHR_MAINTENANCE_3_EXTENSION_NAME
 KHR_draw_indirect_count                                 :: 1
 KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION                    :: 1
 KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME                  :: "VK_KHR_draw_indirect_count"
@@ -193,9 +202,15 @@ KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME                  :: "VK_KHR_shader_atomic
 KHR_shader_clock                                        :: 1
 KHR_SHADER_CLOCK_SPEC_VERSION                           :: 1
 KHR_SHADER_CLOCK_EXTENSION_NAME                         :: "VK_KHR_shader_clock"
+KHR_global_priority                                     :: 1
+MAX_GLOBAL_PRIORITY_SIZE_KHR                            :: 16
+KHR_GLOBAL_PRIORITY_SPEC_VERSION                        :: 1
+KHR_GLOBAL_PRIORITY_EXTENSION_NAME                      :: "VK_KHR_global_priority"
 KHR_driver_properties                                   :: 1
 KHR_DRIVER_PROPERTIES_SPEC_VERSION                      :: 1
 KHR_DRIVER_PROPERTIES_EXTENSION_NAME                    :: "VK_KHR_driver_properties"
+MAX_DRIVER_NAME_SIZE_KHR                                :: MAX_DRIVER_NAME_SIZE
+MAX_DRIVER_INFO_SIZE_KHR                                :: MAX_DRIVER_INFO_SIZE
 KHR_shader_float_controls                               :: 1
 KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION                  :: 4
 KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME                :: "VK_KHR_shader_float_controls"
@@ -215,7 +230,7 @@ KHR_shader_terminate_invocation                         :: 1
 KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION            :: 1
 KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME          :: "VK_KHR_shader_terminate_invocation"
 KHR_fragment_shading_rate                               :: 1
-KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION                  :: 1
+KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION                  :: 2
 KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME                :: "VK_KHR_fragment_shading_rate"
 KHR_spirv_1_4                                           :: 1
 KHR_SPIRV_1_4_SPEC_VERSION                              :: 1
@@ -268,6 +283,15 @@ KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME     :: "VK_KHR_workgroup_mem
 KHR_copy_commands2                                      :: 1
 KHR_COPY_COMMANDS_2_SPEC_VERSION                        :: 1
 KHR_COPY_COMMANDS_2_EXTENSION_NAME                      :: "VK_KHR_copy_commands2"
+KHR_format_feature_flags2                               :: 1
+KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION                 :: 1
+KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME               :: "VK_KHR_format_feature_flags2"
+KHR_portability_enumeration                             :: 1
+KHR_PORTABILITY_ENUMERATION_SPEC_VERSION                :: 1
+KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME              :: "VK_KHR_portability_enumeration"
+KHR_maintenance4                                        :: 1
+KHR_MAINTENANCE_4_SPEC_VERSION                          :: 2
+KHR_MAINTENANCE_4_EXTENSION_NAME                        :: "VK_KHR_maintenance4"
 EXT_debug_report                                        :: 1
 EXT_DEBUG_REPORT_SPEC_VERSION                           :: 10
 EXT_DEBUG_REPORT_EXTENSION_NAME                         :: "VK_EXT_debug_report"
@@ -374,8 +398,10 @@ NV_geometry_shader_passthrough                          :: 1
 NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION             :: 1
 NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME           :: "VK_NV_geometry_shader_passthrough"
 NV_viewport_array2                                      :: 1
-NV_VIEWPORT_ARRAY2_SPEC_VERSION                         :: 1
-NV_VIEWPORT_ARRAY2_EXTENSION_NAME                       :: "VK_NV_viewport_array2"
+NV_VIEWPORT_ARRAY_2_SPEC_VERSION                        :: 1
+NV_VIEWPORT_ARRAY_2_EXTENSION_NAME                      :: "VK_NV_viewport_array2"
+NV_VIEWPORT_ARRAY2_SPEC_VERSION                         :: NV_VIEWPORT_ARRAY_2_SPEC_VERSION
+NV_VIEWPORT_ARRAY2_EXTENSION_NAME                       :: NV_VIEWPORT_ARRAY_2_EXTENSION_NAME
 NVX_multiview_per_view_attributes                       :: 1
 NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION          :: 1
 NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME        :: "VK_NVX_multiview_per_view_attributes"
@@ -446,7 +472,7 @@ EXT_post_depth_coverage                                 :: 1
 EXT_POST_DEPTH_COVERAGE_SPEC_VERSION                    :: 1
 EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME                  :: "VK_EXT_post_depth_coverage"
 EXT_image_drm_format_modifier                           :: 1
-EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION              :: 1
+EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION              :: 2
 EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME            :: "VK_EXT_image_drm_format_modifier"
 EXT_validation_cache                                    :: 1
 EXT_VALIDATION_CACHE_SPEC_VERSION                       :: 1
@@ -463,6 +489,7 @@ NV_SHADING_RATE_IMAGE_EXTENSION_NAME                    :: "VK_NV_shading_rate_i
 NV_ray_tracing                                          :: 1
 NV_RAY_TRACING_SPEC_VERSION                             :: 3
 NV_RAY_TRACING_EXTENSION_NAME                           :: "VK_NV_ray_tracing"
+SHADER_UNUSED_KHR                                       :: 0
 NV_representative_fragment_test                         :: 1
 NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION            :: 2
 NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME          :: "VK_NV_representative_fragment_test"
@@ -524,14 +551,16 @@ AMD_display_native_hdr                                  :: 1
 AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION                     :: 1
 AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME                   :: "VK_AMD_display_native_hdr"
 EXT_fragment_density_map                                :: 1
-EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION                   :: 1
+EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION                   :: 2
 EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME                 :: "VK_EXT_fragment_density_map"
 EXT_scalar_block_layout                                 :: 1
 EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION                    :: 1
 EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME                  :: "VK_EXT_scalar_block_layout"
 GOOGLE_hlsl_functionality1                              :: 1
-GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION                 :: 1
-GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME               :: "VK_GOOGLE_hlsl_functionality1"
+GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION                :: 1
+GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME              :: "VK_GOOGLE_hlsl_functionality1"
+GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION                 :: GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION
+GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME               :: GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME
 GOOGLE_decorate_string                                  :: 1
 GOOGLE_DECORATE_STRING_SPEC_VERSION                     :: 1
 GOOGLE_DECORATE_STRING_EXTENSION_NAME                   :: "VK_GOOGLE_decorate_string"
@@ -640,6 +669,9 @@ EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME      :: "VK_EXT_pipeline_crea
 NV_device_diagnostics_config                            :: 1
 NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION               :: 1
 NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME             :: "VK_NV_device_diagnostics_config"
+EXT_graphics_pipeline_library                           :: 1
+EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION              :: 1
+EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME            :: "VK_EXT_graphics_pipeline_library"
 NV_fragment_shading_rate_enums                          :: 1
 NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION             :: 1
 NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME           :: "VK_NV_fragment_shading_rate_enums"
@@ -658,6 +690,9 @@ EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME                     :: "VK_EXT_image_robustn
 EXT_4444_formats                                        :: 1
 EXT_4444_FORMATS_SPEC_VERSION                           :: 1
 EXT_4444_FORMATS_EXTENSION_NAME                         :: "VK_EXT_4444_formats"
+EXT_rgba10x6_formats                                    :: 1
+EXT_RGBA10X6_FORMATS_SPEC_VERSION                       :: 1
+EXT_RGBA10X6_FORMATS_EXTENSION_NAME                     :: "VK_EXT_rgba10x6_formats"
 NV_acquire_winrt_display                                :: 1
 NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION                   :: 1
 NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME                 :: "VK_NV_acquire_winrt_display"
@@ -667,6 +702,9 @@ EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME           :: "VK_EXT_vertex_input_
 EXT_physical_device_drm                                 :: 1
 EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION                    :: 1
 EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME                  :: "VK_EXT_physical_device_drm"
+EXT_depth_clip_control                                  :: 1
+EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION                     :: 1
+EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME                   :: "VK_EXT_depth_clip_control"
 EXT_primitive_topology_list_restart                     :: 1
 EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION        :: 1
 EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME      :: "VK_EXT_primitive_topology_list_restart"
@@ -679,20 +717,38 @@ EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME             :: "VK_EXT_extended_dyna
 EXT_color_write_enable                                  :: 1
 EXT_COLOR_WRITE_ENABLE_SPEC_VERSION                     :: 1
 EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME                   :: "VK_EXT_color_write_enable"
+EXT_primitives_generated_query                          :: 1
+EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION             :: 1
+EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME           :: "VK_EXT_primitives_generated_query"
 EXT_global_priority_query                               :: 1
 EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION                  :: 1
 EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME                :: "VK_EXT_global_priority_query"
+EXT_image_view_min_lod                                  :: 1
+EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION                     :: 1
+EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME                   :: "VK_EXT_image_view_min_lod"
 EXT_multi_draw                                          :: 1
 EXT_MULTI_DRAW_SPEC_VERSION                             :: 1
 EXT_MULTI_DRAW_EXTENSION_NAME                           :: "VK_EXT_multi_draw"
+EXT_image_2d_view_of_3d                                 :: 1
+EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION                    :: 1
+EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME                  :: "VK_EXT_image_2d_view_of_3d"
 EXT_load_store_op_none                                  :: 1
 EXT_LOAD_STORE_OP_NONE_SPEC_VERSION                     :: 1
 EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME                   :: "VK_EXT_load_store_op_none"
+EXT_border_color_swizzle                                :: 1
+EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION                   :: 1
+EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME                 :: "VK_EXT_border_color_swizzle"
 EXT_pageable_device_local_memory                        :: 1
 EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION           :: 1
 EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME         :: "VK_EXT_pageable_device_local_memory"
+NV_linear_color_attachment                              :: 1
+NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION                 :: 1
+NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME               :: "VK_NV_linear_color_attachment"
+GOOGLE_surfaceless_query                                :: 1
+GOOGLE_SURFACELESS_QUERY_SPEC_VERSION                   :: 1
+GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME                 :: "VK_GOOGLE_surfaceless_query"
 KHR_acceleration_structure                              :: 1
-KHR_ACCELERATION_STRUCTURE_SPEC_VERSION                 :: 12
+KHR_ACCELERATION_STRUCTURE_SPEC_VERSION                 :: 13
 KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME               :: "VK_KHR_acceleration_structure"
 KHR_ray_tracing_pipeline                                :: 1
 KHR_RAY_TRACING_PIPELINE_SPEC_VERSION                   :: 1
@@ -756,6 +812,7 @@ Framebuffer                   :: distinct NonDispatchableHandle
 CommandPool                   :: distinct NonDispatchableHandle
 SamplerYcbcrConversion        :: distinct NonDispatchableHandle
 DescriptorUpdateTemplate      :: distinct NonDispatchableHandle
+PrivateDataSlot               :: distinct NonDispatchableHandle
 SurfaceKHR                    :: distinct NonDispatchableHandle
 SwapchainKHR                  :: distinct NonDispatchableHandle
 DisplayKHR                    :: distinct NonDispatchableHandle
@@ -769,7 +826,6 @@ ValidationCacheEXT            :: distinct NonDispatchableHandle
 AccelerationStructureNV       :: distinct NonDispatchableHandle
 PerformanceConfigurationINTEL :: distinct NonDispatchableHandle
 IndirectCommandsLayoutNV      :: distinct NonDispatchableHandle
-PrivateDataSlotEXT            :: distinct NonDispatchableHandle
 AccelerationStructureKHR      :: distinct NonDispatchableHandle